expect-pty 0.5.2 → 0.6.1

data/test/matching_test.rb

@@ -1,211 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class MatchingTest < ExpectTest
-  def test_literal_regexp_number_and_result_tuple
-    session, = pipe_session
-    session.buffer = "before a.c between abc:42 after"
-    assert_equal 2, session.expect("absent", "a.c", timeout: 0)
-    assert_equal "before ", session.before
-    assert_equal "a.c", session.match
-    result = session.expect_result(/abc:(\d+)/, timeout: 0)
-    assert_equal [1, nil, "abc:42", " between ", " after", session, ["42"]], result.to_a
-    assert_equal ["42"], session.captures
-    assert result.matched?
-    refute result.timeout?
-    refute result.eof?
-  end
-
-  def test_regexp_callback_captures_lexical_arguments
-    session, = pipe_session
-    session.buffer = "prefix xyz42 suffix"
-    observed = []
-    argument = :value
-    number = session.expect(timeout: 0) do
-      on(/xyz(\d+)/) { |object| observed << [object.captures, argument] }
-    end
-    assert_equal 1, number
-    assert_equal [[["42"], :value]], observed
-  end
-
-  def test_native_regexp_and_literal_event_names
-    session, = pipe_session
-    session.buffer = "timeout eof -word a.c end99"
-    assert_equal 1, session.expect("timeout", timeout: 0)
-    assert_equal 1, session.expect("eof", timeout: 0)
-    assert_equal 1, session.expect("-word", timeout: 0)
-    assert_equal 1, session.expect("a.c", timeout: 0)
-    assert_equal 1, session.expect(/end\d+/, timeout: 0)
-  end
-
-  def test_patterns_have_priority_over_their_position_in_buffer
-    session, = pipe_session
-    session.buffer = "second first"
-    assert_equal 1, session.expect("first", "second", timeout: 0)
-    assert_equal "second ", session.before
-  end
-
-  def test_regexp_uses_actual_offset_with_lookbehind
-    session, = pipe_session
-    session.buffer = "same prefix same end"
-    session.expect(/(?<=prefix )same/, timeout: 0)
-    assert_equal "same prefix ", session.before
-    assert_equal " end", session.after
-  end
-
-  def test_unmatched_capture_and_zero_width_pattern
-    session, = pipe_session
-    session.buffer = "b"
-    assert_equal 1, session.expect(/(a)?(?=b)/, timeout: 0)
-    assert_equal [nil], session.captures
-    assert_equal "", session.match
-    assert_equal "b", session.buffer
-  end
-
-  def test_capture_list_clears_for_literal_and_timeout
-    session, = pipe_session
-    session.buffer = "a1 b"
-    session.expect(/a(\d)/, timeout: 0)
-    session.expect("b", timeout: 0)
-    assert_empty session.captures
-    assert_nil session.expect(/absent/, timeout: 0)
-    assert_nil session.match
-    assert_nil session.after
-    assert_empty session.captures
-  end
-
-  def test_buffer_retained_on_timeout_and_manually_replaceable
-    session, writer = pipe_session
-    writer.write("some string")
-    assert_nil session.expect("other", timeout: 0.03)
-    assert_equal :timeout, session.error
-    assert_equal "some string", session.before
-    assert_equal 1, session.expect("some", timeout: 0)
-    assert_equal " string", session.buffer
-    session.buffer = "new"
-    assert_equal "new", session.clear_buffer
-    assert_empty session.buffer
-  end
-
-  def test_preserve_buffer_and_buffer_limit
-    session, = pipe_session
-    session.preserve_buffer = true
-    session.buffer = "prefix token tail"
-    2.times { assert_equal 1, session.expect("token", timeout: 0) }
-    assert_equal "prefix token tail", session.buffer
-    session.buffer_limit = 4
-    assert_equal "tail", session.buffer
-    session.buffer_limit = nil
-    session.buffer = "123456"
-    assert_equal "123456", session.buffer
-  end
-
-  def test_split_patterns_across_reads
-    session, writer = pipe_session
-    background do
-      writer.write("pass")
-      sleep 0.03
-      writer.write("word: ")
-    end
-    assert_equal 1, session.expect(/password: /, timeout: 1)
-  end
-
-  def test_utf8_regexp_split_character_and_byte_offsets
-    session, writer = pipe_session
-    bytes = "前缀密码：结束".b
-    background do
-      bytes.each_byte do |byte|
-        writer.write(byte.chr)
-        sleep 0.001
-      end
-    end
-    assert_equal 1, session.expect(/(密码)：/, timeout: 1)
-    assert_equal "前缀".b, session.before
-    assert_equal ["密码".b], session.captures
-    assert_equal 1, session.expect("结束", timeout: 1)
-  end
-
-  def test_utf8_regexp_waits_for_incomplete_trailing_character_before_matching
-    session, writer = pipe_session
-    session.buffer = "ready\xE4".b
-
-    assert_nil session.expect(/ready\z/u, timeout: 0)
-    assert_nil session.expect(/ready/u, timeout: 0)
-    assert_equal "ready\xE4".b, session.buffer
-
-    writer.write("\xB8\xAD".b)
-    assert_equal 1, session.expect(/ready中\z/u, timeout: 1)
-    assert_equal "ready中".b, session.match
-  end
-
-  def test_binary_nul_and_invalid_utf8
-    session, writer = pipe_session
-    writer.write("\xff\x00abc\xfe".b)
-    assert_equal 1, session.expect(/\x00(abc)/n, timeout: 1)
-    assert_equal "\xff".b, session.before
-    assert_equal ["abc"], session.captures
-  end
-
-  def test_utf8_regexp_rejects_impossible_partial_characters
-    session, = pipe_session
-    ["\xE0\x80", "\xED\xA0", "\xF0\x80", "\xF4\x90"].each do |bytes|
-      session.buffer = bytes.b
-      assert_raises(EncodingError) { session.expect(/ready/u, timeout: 0) }
-      assert_equal bytes.b, session.buffer
-    end
-  end
-
-  def test_utf8_regexp_accepts_valid_partial_characters
-    session, = pipe_session
-    ["¢", "中", "😀", "\u{10FFFF}"].each do |character|
-      1.upto(character.bytesize - 1) do |length|
-        session.buffer = character.b.byteslice(0, length)
-        assert_nil session.expect(/./u, timeout: 0)
-        assert_equal character.b.byteslice(0, length), session.buffer
-      end
-    end
-  end
-
-  def test_native_regexp_anchors_and_flags
-    session, = pipe_session
-    session.buffer = "a\nb\nc"
-    session.preserve_buffer = true
-    assert_nil session.expect("^b$", timeout: 0)
-    assert_nil session.expect(/\Ab\z/, timeout: 0)
-    assert_equal 1, session.expect(/^b$/, timeout: 0)
-    assert_equal 1, session.expect(/a.b/m, timeout: 0)
-    assert_nil session.expect(/a.b/, timeout: 0)
-  end
-
-  def test_eof_callback_consumes_remaining_buffer
-    session, writer = pipe_session
-    writer.write("last bytes")
-    writer.close
-    seen = nil
-    result = session.expect_result(timeout: 1) { eof { |object| seen = object.before } }
-    assert_nil result.number
-    assert result.eof?
-    assert_equal "last bytes", seen
-    assert_empty session.buffer
-  end
-
-  def test_read_without_patterns_and_match_before_eof
-    session, writer = pipe_session
-    writer.write("END")
-    writer.close
-    assert_equal 1, session.expect("END", timeout: nil)
-    assert session.expect_result(timeout: nil).eof?
-  end
-
-  def test_argument_validation_does_not_read_io
-    session, = pipe_session
-    assert_raises(ArgumentError) { session.expect("x", timeout: -1) }
-    assert_raises(ArgumentError) { session.expect("x", timeout: Float::INFINITY) }
-    assert_raises(ArgumentError) { session.expect(["a", 42], timeout: 0) }
-    assert_raises(ArgumentError) { session.expect("-i", [], timeout: 0) }
-    assert_raises(ArgumentError) { session.expect(Object.new, timeout: 0) }
-    assert_raises(ArgumentError) { Expect.expect("x", timeout: 0) }
-    assert_raises(ArgumentError) { session.buffer_limit = -1 }
-  end
-end

data/test/multi_session_test.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class MultiSessionTest < ExpectTest
-  def test_multi_session_pattern_groups_and_global_numbering
-    first, first_writer = pipe_session
-    second, second_writer = pipe_session
-    first_writer.write("irrelevant")
-    second_writer.write("second:42")
-    result = Expect.expect_result(timeout: 1) do
-      on("first", from: first)
-      on(/second:(\d+)/, from: second)
-    end
-    assert_equal 2, result.number
-    assert_same second, result.session
-    assert_equal ["42"], result.captures
-    assert_equal "irrelevant", first.buffer
-  end
-
-  def test_shared_patterns_across_sessions
-    first, = pipe_session
-    second, writer = pipe_session
-    writer.write("ready")
-    assert_equal 1, Expect.expect("ready", from: [first, second], timeout: 1)
-    assert_equal "ready", second.match
-  end
-
-  def test_eof_continue_removes_closed_session_and_waits_for_remaining
-    first, first_writer = pipe_session
-    second, second_writer = pipe_session
-    first_writer.close
-    ended = []
-    result = Expect.expect_result(timeout: 1) do
-      eof(from: first) do |connection|
-        ended << connection
-        second_writer.write("done")
-        Expect.continue(reset_timeout: false)
-      end
-      on("done", from: second)
-    end
-    assert_equal [first], ended
-    assert_equal 2, result.number
-    assert_same second, result.session
-  end
-
-  def test_all_eof_continuation_returns_without_waiting_forever
-    first, writer = pipe_session
-    writer.close
-    result = bounded { first.expect_result(timeout: nil) { eof { Expect.continue } } }
-    assert result.eof?
-  end
-
-  def test_same_session_in_multiple_groups_is_read_once
-    session, writer = pipe_session
-    writer.write("right")
-    other, = pipe_session
-    result = Expect.expect_result(timeout: 1) do
-      on("wrong", from: session)
-      on("missing", from: other)
-      on("right", from: session)
-    end
-    assert_equal 3, result.number
-    assert_equal "right", result.match
-  end
-end

data/test/pattern_offset_test.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class PatternOffsetTest < ExpectTest
-  def test_byte_offsets_captures_and_buffer_consumption
-    cases = [
-      ["abENDtail", /END/, 2, 3, []],
-      ["中文终点尾", /(终)(点)/, 6, 6, ["终".b, "点".b]],
-      ["😀中😀尾", /(😀)(x)?/, 0, 4, ["😀".b, nil]],
-      ["😀中END尾", /END/, 7, 3, []],
-      ["a\0b", /(\0)/n, 1, 1, ["\0".b]],
-      ["\xFF\x00\xFE".b, /(\xFE)/n, 2, 1, ["\xFE".b]],
-      ["中文尾", /(?=尾)/, 6, 0, []],
-      ["😀", /$/u, 4, 0, []]
-    ]
-    session, = pipe_session
-    cases.each do |text, regexp, offset, length, captures|
-      # 扫描只读调用者输入；省去正则副本后也不能改变编码标记或冻结字符串。
-      bytes = text.b.freeze
-      assert_equal [offset, length, captures], Expect::Pattern.new(value: regexp).locate(bytes)
-      assert_equal Encoding::BINARY, bytes.encoding
-      session.buffer = bytes
-      result = session.expect_result(regexp, timeout: 0)
-      assert_equal bytes.byteslice(0, offset), result.before
-      assert_equal bytes.byteslice(offset, length), result.match
-      assert_equal bytes.byteslice((offset + length)..), result.after
-      assert_equal captures, result.captures
-      assert_equal result.after, session.buffer
-    end
-  end
-
-  def test_incomplete_utf8_defers_matching_and_eof_still_rejects_it
-    pattern = Expect::Pattern.new(value: /中(?=😀)/)
-    bytes = "前中😀".b
-    (1..3).each do |missing|
-      partial = bytes.byteslice(0, bytes.bytesize - missing)
-      assert_nil pattern.locate(partial)
-      assert_raises(EncodingError) { pattern.locate(partial, final: true) }
-    end
-    assert_equal [3, 3, []], pattern.locate(bytes)
-  end
-end

data/test/process_test.rb

@@ -1,291 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class ProcessTest < ExpectTest
-  def test_spawn_has_controlling_terminal_and_merged_stderr
-    session = child(<<~RUBY)
-      terminal = File.open("/dev/tty", &:tty?)
-      puts [STDIN.tty?, STDOUT.tty?, STDERR.tty?, terminal].join(":")
-      STDERR.puts "error-stream"
-    RUBY
-    assert_equal 1, session.expect("true:true:true:true", timeout: 2)
-    assert_equal 1, session.expect("error-stream", timeout: 2)
-    session.soft_close(timeout: 1)
-    assert_equal 0, session.exit_code
-    assert_equal 0, session.process_status.to_i
-    assert session.closed?
-    refute session.alive?
-  end
-
-  def test_raw_mode_is_applied_before_child_starts
-    session = child(<<~'RUBY', raw_pty: true)
-      print "name: "
-      value = STDIN.gets
-      puts "reply=#{value.strip.reverse}"
-    RUBY
-    session.expect("name: ", timeout: 2)
-    session.write("crate\n")
-    assert_equal 1, session.expect("reply=etarc\n", timeout: 2)
-    assert_equal "", session.before
-  end
-
-  def test_new_pty_supports_slave_configuration_before_spawn
-    session = Expect.new(log_stdout: false)
-    @sessions << session
-    assert session.slave.tty?
-    session.slave.echo = false
-    session.slave.winsize = [37, 111]
-    # 子进程需要 io-console gem，保留 RubyGems 以使用 Bundler 选定的版本。
-    session.spawn(RbConfig.ruby, "-rio/console", "-e",
-                  'STDOUT.sync = true; puts STDIN.winsize.join(":"); puts STDIN.gets')
-    assert_equal 1, session.expect("37:111", timeout: 2), session.before.inspect
-    assert_equal [37, 111], session.winsize
-    session.winsize = [24, 80]
-    assert_equal [24, 80], session.winsize
-    session.clear_buffer
-    session.write("line\n")
-    session.expect("line", timeout: 2)
-    session.expect(timeout: 2)
-    assert_equal "\r\n", session.before
-  end
-
-  def test_command_arguments_environment_and_directory
-    Dir.mktmpdir do |dir|
-      session = Expect.spawn(RbConfig.ruby, "--disable-gems", "-e",
-                             'puts ARGV.first; puts ENV.fetch("EXPECT_TEST_VALUE"); puts Dir.pwd', "a;$(exit) b",
-                             env: { "EXPECT_TEST_VALUE" => "environment" }, chdir: dir,
-                             log_stdout: false, raw_pty: true)
-      @sessions << session
-      assert_equal 1, session.expect("a;$(exit) b\nenvironment\n#{File.realpath(dir)}\n", timeout: 2)
-    end
-  end
-
-  def test_string_command_supports_shell_semantics
-    session = Expect.new("printf 'shell-one'; printf 'shell-two'", log_stdout: false)
-    @sessions << session
-    assert_equal 1, session.expect("shell-oneshell-two", timeout: 2)
-  end
-
-  def test_exec_failure_is_synchronous_and_reaped
-    session = Expect.new(log_stdout: false)
-    @sessions << session
-    error = assert_raises(Expect::SpawnError) { session.spawn("/no/such/expect-test-command") }
-    assert_match(/ENOENT/, error.message)
-    assert session.closed?
-    assert_nil session.pid
-    assert_raises(Expect::SpawnError) { session.spawn("cat") }
-  end
-
-  def test_spawn_cleans_child_when_post_exec_diagnostics_fail
-    assert_failed_construction_cleans_child(:spawn)
-  end
-
-  def test_new_cleans_child_when_post_exec_diagnostics_fail
-    assert_failed_construction_cleans_child(:new)
-  end
-
-  def test_block_closes_child_on_exception
-    pid = nil
-    assert_raises(RuntimeError) do
-      Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", "sleep 60", log_stdout: false) do |session|
-        pid = session.pid
-        raise "stop"
-      end
-    end
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-    assert_raises(Errno::ESRCH) { Process.kill(0, pid) }
-  end
-
-  def test_soft_close_drains_output_before_exit_and_returns_process_status
-    session = child('sleep 0.03; print "last output"; exit 7', raw_pty: true)
-    log = StringIO.new
-    session.log_to(log)
-    assert_equal 7, session.soft_close(timeout: 1).exitstatus
-    assert_equal "last output", log.string
-    assert_equal "last output", session.buffer
-    assert_equal 7, session.exit_code
-    refute log.closed?
-  end
-
-  def test_hard_close_escalates_uncooperative_child_and_reaps
-    session = child('Signal.trap("HUP", "IGNORE"); Signal.trap("TERM", "IGNORE"); puts "ready"; loop { sleep 1 }')
-    session.expect("ready", timeout: 2)
-    pid = session.pid
-    bounded(2) { session.hard_close(timeout: 0.03) }
-    assert_equal Signal.list.fetch("KILL"), session.process_status.termsig
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-    assert_equal session.process_status, session.hard_close
-  end
-
-  def test_soft_close_sends_term_and_returns_the_exit_status
-    session = child(<<~RUBY, raw_pty: true)
-      Signal.trap("HUP", "IGNORE")
-      Signal.trap("TERM") { exit 7 }
-      puts "ready"
-      sleep 60
-    RUBY
-    session.expect("ready", timeout: 2)
-    status = bounded { session.soft_close(timeout: 0, term_timeout: 1) }
-    assert_equal 7, status.exitstatus
-    assert session.closed?
-    refute session.alive?
-    assert_same status, session.soft_close(timeout: 0)
-  end
-
-  def test_soft_close_never_sends_kill_and_retains_a_live_pid_for_hard_close
-    session = child(<<~RUBY)
-      Signal.trap("HUP", "IGNORE")
-      Signal.trap("TERM", "IGNORE")
-      puts "ready"
-      sleep 60
-    RUBY
-    session.expect("ready", timeout: 2)
-    pid = session.pid
-    assert_nil(bounded { session.soft_close(timeout: 0, term_timeout: 0.03) })
-    assert session.closed?
-    assert session.alive?
-    assert_equal pid, session.pid
-    assert_nil session.wait(timeout: 0)
-    status = bounded { session.hard_close(timeout: 0.03) }
-    assert_equal Signal.list.fetch("KILL"), status.termsig
-    assert_nil session.pid
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-  end
-
-  def test_block_cleanup_uses_the_configured_graceful_close_and_drains_output
-    log = StringIO.new
-    connection = nil
-    value = Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", 'sleep 0.03; puts "tail"',
-                         raw_pty: true, graceful_close: true) do |session|
-      connection = session
-      session.log_output = log
-      :finished
-    end
-    assert_equal :finished, value
-    assert_equal "tail\n", log.string
-    assert connection.closed?
-    assert_equal 0, connection.exit_code
-    refute log.closed?
-  end
-
-  def test_explicit_graceful_close_returns_nil_like_io_close
-    session = child('sleep 0.03; print "tail"', raw_pty: true)
-    assert_nil session.close(graceful: true)
-    assert_equal "tail", session.buffer
-    assert_equal 0, session.exit_code
-    assert_nil session.close
-  end
-
-  def test_close_still_reaps_the_child_when_graceful_logging_fails
-    session = child('puts "ready"; sleep 60', raw_pty: true)
-    pid = session.pid
-    session.log_to { raise IOError, "log failed" }
-    assert_raises(IOError) { bounded { session.close(graceful: true) } }
-    assert session.closed?
-    refute session.alive?
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-  end
-
-  def test_invalid_close_timeout_does_not_close_or_signal_the_child
-    session = child('puts "ready"; sleep 60')
-    session.expect("ready", timeout: 2)
-    assert_raises(ArgumentError) { session.soft_close(timeout: 0, term_timeout: nil) }
-    assert_raises(ArgumentError) { session.soft_close(timeout: 0, term_timeout: -1) }
-    assert_raises(ArgumentError) { session.hard_close(timeout: nil) }
-    refute session.closed?
-    assert session.alive?
-  end
-
-  def test_eof_does_not_prevent_buffered_match
-    session = child('print "final"; exit 4', raw_pty: true)
-    assert_equal 1, session.expect("final", timeout: 2)
-    assert session.expect_result(:eof, timeout: 2).eof?
-    assert_equal 4, session.wait(timeout: 1).exitstatus
-  end
-
-  def test_wait_timeout_and_explicit_close
-    session = child("sleep 0.15; exit 0")
-    assert_nil session.wait(timeout: 0)
-    assert session.alive?
-    assert_equal 0, session.wait(timeout: 1).exitstatus
-    refute session.alive?
-    session.close
-    assert_raises(IOError) { session.write("x") }
-  end
-
-  def test_borrowed_and_owned_io_lifetimes
-    session, writer = pipe_session
-    reader = session.to_io
-    session.close
-    refute reader.closed?
-    writer.write("x")
-    assert_equal "x", reader.read(1)
-    owned = Expect.open(reader, own: true)
-    owned.close
-    assert reader.closed?
-  end
-
-  def test_stty_roundtrip
-    session = child("sleep 30")
-    initial = session.stty
-    configuration = terminal_configuration(session)
-    session.stty("raw -echo")
-    refute session.to_io.echo?
-    session.stty(initial)
-    assert_equal configuration, terminal_configuration(session)
-  end
-
-  def test_stty_reports_a_missing_system_command_and_preserves_the_cause
-    previous_path = ENV.fetch("PATH", nil)
-    session = child("sleep 60")
-    ENV["PATH"] = ""
-    error = assert_raises(IOError) { session.stty }
-    assert_match "stty executable not found", error.message
-    assert_instance_of Errno::ENOENT, error.cause
-  ensure
-    ENV["PATH"] = previous_path
-  end
-
-  def test_configuration_and_session_attributes
-    Expect.configure(timeout: 0.01, log_stdout: false)
-    session = Expect.new
-    @sessions << session
-    refute session.log_stdout?
-    assert_equal 0.01, session.timeout
-    session.log_stdout = true
-    assert session.log_stdout
-    session.log_stdout = false
-    refute session.log_stdout
-    session.buffer_limit = 30
-    assert_equal 30, session.buffer_limit
-    assert_match(/\A#<Expect .*closed=false>\z/, session.inspect)
-  end
-
-  private
-
-  def assert_failed_construction_cleans_child(factory)
-    connection = nil
-    session_class = Class.new(Expect)
-    session_class.define_method(:initialize) do |*command, **options|
-      connection = self
-      super(*command, **options)
-    end
-    reader, diagnostic_output = IO.pipe
-    @ios.push(reader, diagnostic_output)
-    reader.close
-    previous_stderr = $stderr
-    begin
-      $stderr = diagnostic_output
-      assert_raises(Errno::EPIPE) do
-        session_class.public_send(factory, RbConfig.ruby, "--disable-gems", "-e", "sleep 60", debug_level: 1)
-      end
-    ensure
-      $stderr = previous_stderr
-      @sessions << connection if connection
-    end
-    assert connection.closed?
-    assert_nil connection.pid
-    assert_instance_of Process::Status, connection.process_status
-  end
-end