iruby 0.3 → 0.7.0

data/test/helper.rb

@@ -0,0 +1,136 @@
+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?
+
+      out, err = capture_io do
+        yield
+      end
+
+      y = check_assert_output_result(stderr, err, "stderr")
+      x = check_assert_output_result(stdout, out, "stdout")
+
+      (!stdout || x) && (!stderr || y)
+    end
+
+    private
+
+    def capture_io
+      captured_stdout = StringIO.new
+      captured_stderr = StringIO.new
+
+      orig_stdout, $stdout = $stdout, captured_stdout
+      orig_stderr, $stderr = $stderr, captured_stderr
+
+      yield
+
+      return captured_stdout.string, captured_stderr.string
+    ensure
+      $stdout = orig_stdout
+      $stderr = orig_stderr
+    end
+
+    def check_assert_output_result(expected, actual, name)
+      if expected
+        message = "In #{name}"
+        case expected
+        when Regexp
+          assert_match(expected, actual, message)
+        else
+          assert_equal(expected, actual, message)
+        end
+      end
+    end
+
+    def ignore_warning
+      saved, $VERBOSE = $VERBOSE , nil
+      yield
+    ensure
+      $VERBOSE = saved
+    end
+
+    def with_env(env)
+      keys = env.keys
+      saved_values = ENV.values_at(*keys)
+      ENV.update(env)
+      yield
+    ensure
+      if keys && saved_values
+        keys.zip(saved_values) do |k, v|
+          ENV[k] = v
+        end
+      end
+    end
+
+    def windows_only
+      omit('windows only test') unless windows?
+    end
+
+    def apple_only
+      omit('apple only test') unless windows?
+    end
+
+    def unix_only
+      omit('unix only test') if windows? || apple?
+    end
+
+    def windows?
+      /mingw|mswin/ =~ RUBY_PLATFORM
+    end
+
+    def apple?
+      /darwin/ =~ RUBY_PLATFORM
+    end
+  end
+end

data/test/integration_test.rb

@@ -1,40 +1,51 @@
-require 'test_helper'
-require 'open3'
+require 'pty'
 require 'expect'
 
-class IntegrationTest < IRubyTest
+class IRubyTest::IntegrationTest < IRubyTest::TestBase
   def setup
-    @stdin, @stdout, @stderr, @process = Open3.popen3('bin/iruby')
+    $expect_verbose = false # make true if you want to dump the output of iruby console
+
+    @in, @out, pid = PTY.spawn('bin/iruby --simple-prompt')
+    @waiter = Thread.start { Process.waitpid(pid) }
     expect 'In [', 30
     expect '1'
     expect ']:'
   end
 
   def teardown
-    @stdin.close
-    @stdout.close
-    @stderr.close
-    @process.kill
+    @in.close
+    @out.close
+    @waiter.join
   end
 
   def write(input)
-    @stdin.puts input
+    @out.puts input
   end
 
-  def expect(pattern, timeout = 1)
-    assert @stdout.expect(pattern, timeout), "#{pattern} expected"
+  def expect(pattern, timeout = 10)
+    assert @in.expect(pattern, timeout), "#{pattern} expected, but timeout"
+  end
+
+  def wait_prompt
+    expect 'In ['
+    expect ']:'
   end
 
   def test_interaction
+    omit("This test too much unstable")
+
     write '"Hello, world!"'
     expect '"Hello, world!"'
 
+    wait_prompt
     write 'puts "Hello!"'
     expect 'Hello!'
 
+    wait_prompt
     write '12 + 12'
     expect '24'
 
+    wait_prompt
     write 'ls'
     expect 'self.methods'
   end

data/test/iruby/backend_test.rb

@@ -0,0 +1,37 @@
+module IRubyTest
+  class PlainBackendTest < IRubyTest::TestBase
+    def setup
+      @plainbackend = IRuby::PlainBackend.new
+    end
+
+    def test_eval_one_plus_two
+      assert_equal 3, @plainbackend.eval('1+2', false)
+    end
+
+    def test_complete_req
+      assert_includes @plainbackend.complete('req'), 'require'
+    end
+
+    def test_complete_2_dot
+      assert_includes @plainbackend.complete('2.'), '2.even?'
+    end
+  end
+
+  class PryBackendTest < IRubyTest::TestBase
+    def setup
+      @prybackend = IRuby::PryBackend.new
+    end
+
+    def test_eval_one_plus_two
+      assert_equal 3, @prybackend.eval('1+2', false)
+    end
+
+    def test_complete_req
+      assert_includes @prybackend.complete('req'), 'require'
+    end
+
+    def test_complete_2_dot
+      assert_includes @prybackend.complete('2.'), '2.even?'
+    end
+  end
+end

data/test/iruby/command_test.rb

@@ -0,0 +1,207 @@
+require 'iruby/command'
+
+module IRubyTest
+  class CommandTest < TestBase
+    def test_with_empty_argv
+      with_env('JUPYTER_DATA_DIR' => nil,
+               'IPYTHONDIR' => nil) do
+        assert_output(nil, /\A\z/) do
+          @command = IRuby::Command.new([])
+          kernel_dir = File.join(IRuby::Jupyter.kernelspec_dir, 'ruby')
+          assert_equal(kernel_dir, @command.kernel_dir)
+          assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+        end
+      end
+    end
+
+    def test_with_JUPYTER_DATA_DIR
+      Dir.mktmpdir do |tmpdir|
+        with_env('JUPYTER_DATA_DIR' => tmpdir,
+                 'IPYTHONDIR' => nil) do
+          assert_output(nil, /\A\z/) do
+            @command = IRuby::Command.new([])
+            kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+            assert_equal(kernel_dir, @command.kernel_dir)
+            assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+          end
+        end
+      end
+    end
+
+    def test_with_IPYTHONDIR
+      Dir.mktmpdir do |tmpdir|
+        with_env('JUPYTER_DATA_DIR' => nil,
+                 'IPYTHONDIR' => tmpdir) do
+          assert_output(nil, /IPYTHONDIR is deprecated\. Use JUPYTER_DATA_DIR instead\./) do
+            @command = IRuby::Command.new([])
+            kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+            assert_equal(kernel_dir, @command.kernel_dir)
+            assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+          end
+        end
+      end
+    end
+
+    def test_with_JUPYTER_DATA_DIR_and_IPYTHONDIR
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => tmpdir,
+                   'IPYTHONDIR' => tmpdir2) do
+            assert_output(nil, /both JUPYTER_DATA_DIR and IPYTHONDIR are supplied; IPYTHONDIR is ignored\./) do
+              @command = IRuby::Command.new([])
+              kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+              assert_equal(kernel_dir, @command.kernel_dir)
+              assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+            end
+          end
+        end
+      end
+    end
+
+    def test_with_ipython_dir_option
+      Dir.mktmpdir do |tmpdir|
+        with_env('JUPYTER_DATA_DIR' => nil,
+                 'IPYTHONDIR' => nil) do
+          assert_output(nil, /--ipython-dir is deprecated\. Use JUPYTER_DATA_DIR environment variable instead\./) do
+            @command = IRuby::Command.new(%W[--ipython-dir=#{tmpdir}])
+            kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+            assert_equal(kernel_dir, @command.kernel_dir)
+            assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+          end
+        end
+      end
+    end
+
+    def test_with_JUPYTER_DATA_DIR_and_ipython_dir_option
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => tmpdir,
+                   'IPYTHONDIR' => nil) do
+            assert_output(nil, /both JUPYTER_DATA_DIR and --ipython-dir are supplied; --ipython-dir is ignored\./) do
+              @command = IRuby::Command.new(%W[--ipython-dir=#{tmpdir2}])
+              kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+              assert_equal(kernel_dir, @command.kernel_dir)
+              assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+            end
+          end
+        end
+      end
+    end
+
+    def test_register_when_there_is_kernel_in_ipython_dir
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => nil,
+                   'IPYTHONDIR' => nil,
+                   'HOME' => tmpdir2) do
+            ignore_warning do
+              @command = IRuby::Command.new(["register", "--ipython-dir=~/.ipython"])
+              assert_equal("#{tmpdir2}/.ipython/kernels/ruby/kernel.json", @command.kernel_file)
+              @command.run
+              assert(File.file?("#{tmpdir2}/.ipython/kernels/ruby/kernel.json"))
+            end
+          end
+
+          with_env('JUPYTER_DATA_DIR' => nil,
+                   'IPYTHONDIR' => nil,
+                   'HOME' => tmpdir2) do
+            @command = IRuby::Command.new(["register"])
+            assert_output(nil, /IRuby kernel file already exists in the deprecated IPython's data directory\.\nUsing --force, you can replace the old kernel file with the new one in Jupyter's data directory\./) do
+              @command.run
+            end
+            assert(File.file?(File.join(@command.ipython_kernel_dir, 'kernel.json')))
+            refute(File.file?(@command.kernel_file))
+
+            @command = IRuby::Command.new(["register", "--force"])
+            assert_output(nil, nil) do
+              @command.run
+            end
+            refute(File.exist?(@command.ipython_kernel_dir))
+            assert(File.file?(@command.kernel_file))
+          end
+        end
+      end
+    end
+
+    def test_register_and_unregister_with_JUPYTER_DATA_DIR
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => tmpdir,
+                   'IPYTHONDIR' => nil,
+                   'HOME' => tmpdir2) do
+            assert_output(nil, nil) do
+              @command = IRuby::Command.new(['register'])
+              kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+              kernel_file = File.join(kernel_dir, 'kernel.json')
+              assert(!File.file?(kernel_file))
+
+              @command.run
+              assert(File.file?(kernel_file))
+
+              @command = IRuby::Command.new(['unregister'])
+              @command.run
+              assert(!File.file?(kernel_file))
+            end
+          end
+        end
+      end
+    end
+
+    def test_register_and_unregister_with_JUPYTER_DATA_DIR_when_there_is_kernel_in_ipython_dir
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('HOME' => tmpdir2) do
+            ignore_warning do
+              @command = IRuby::Command.new(["register", "--ipython-dir=~/.ipython"])
+              assert_equal("#{tmpdir2}/.ipython/kernels/ruby/kernel.json", @command.kernel_file)
+              @command.run
+              assert(File.file?("#{tmpdir2}/.ipython/kernels/ruby/kernel.json"))
+            end
+          end
+
+          with_env('JUPYTER_DATA_DIR' => tmpdir,
+                   'IPYTHONDIR' => nil,
+                   'HOME' => tmpdir2) do
+            @command = IRuby::Command.new(["register"])
+            assert_output(nil, /IRuby kernel file already exists in the deprecated IPython's data directory\.\nUsing --force, you can replace the old kernel file with the new one in Jupyter's data directory\./) do
+              @command.run
+            end
+            assert(File.file?(File.join(@command.ipython_kernel_dir, 'kernel.json')))
+            refute(File.file?(@command.kernel_file))
+
+            @command = IRuby::Command.new(["register", "--force"])
+            assert_output(nil, nil) do
+              @command.run
+            end
+            refute(File.file?(File.join(@command.ipython_kernel_dir, 'kernel.json')))
+            assert(File.file?(@command.kernel_file))
+          end
+        end
+      end
+    end
+
+    def test_register_and_unregister_with_IPYTHONDIR
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => nil,
+                   'IPYTHONDIR' => tmpdir,
+                   'HOME' => tmpdir2) do
+            ignore_warning do
+              @command = IRuby::Command.new(['register'])
+              kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+              kernel_file = File.join(kernel_dir, 'kernel.json')
+              assert(!File.file?(kernel_file))
+
+              @command.run
+              assert(File.file?(kernel_file))
+
+              @command = IRuby::Command.new(['unregister'])
+              @command.run
+              assert(!File.file?(kernel_file))
+            end
+          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