expect-pty 0.2.0 → 0.3.1

data/test/interact_test.rb

@@ -25,6 +25,71 @@ class InteractTest < ExpectTest
     [master, slave, source]
   end
 
+  def socket_session
+    local, peer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(local, peer)
+    session = Expect.open(local)
+    @sessions << session
+    [session, peer]
+  end
+
+  def test_changed_interact_regexp_does_not_match_previously_forwarded_input
+    session, peer = socket_session
+    input, keyboard = pipe_session
+    keyboard.write("old")
+    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
+    assert_equal "old", peer.read_nonblock(100)
+
+    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /old/, timeout: 0)
+    keyboard.write("oldtail")
+    stopped = session.interact(input: input.to_io, output: StringIO.new, escape: /old/, timeout: 0.1)
+    assert_same input.to_io, stopped.to_io
+    assert_equal "tail", stopped.buffer
+  end
+
+  def test_same_interact_regexp_keeps_cross_call_history_and_unread_tail
+    session, peer = socket_session
+    input, keyboard = pipe_session
+    keyboard.write("ST")
+    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
+    assert_equal "ST", peer.read_nonblock(100)
+
+    keyboard.write("OPtail")
+    stopped = session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0.1)
+    assert_same input.to_io, stopped.to_io
+    assert_equal "tail", stopped.buffer
+    assert_nil session.interact(input: input.to_io, output: StringIO.new, escape: /STOP/, timeout: 0)
+    assert_equal "tail", peer.read_nonblock(100)
+  end
+
+  def test_repeated_interact_keeps_split_crlf_on_the_same_terminal
+    session, = socket_session
+    master, slave, source = local_terminal
+    session.buffer = "first\r"
+    assert_nil session.interact(input: source, output: slave, timeout: 0)
+    assert_equal "first\r", master.read_nonblock(100)
+
+    session.buffer = "\nsecond"
+    assert_nil session.interact(input: source, output: slave, timeout: 0)
+    assert_equal "\nsecond", master.read_nonblock(100)
+  end
+
+  def test_changed_interact_regexp_preserves_pending_output_and_tail
+    session, peer = socket_session
+    input, keyboard = pipe_session
+    loop { break if session.writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
+    keyboard.write("old")
+    assert_nil session.interact(input: input, output: StringIO.new, escape: /STOP/, timeout: 0)
+    assert input.pending_output?
+    input.buffer = "tail"
+    loop { break if peer.read_nonblock(65_536, exception: false) == :wait_readable }
+
+    assert_nil session.interact(input: input, output: StringIO.new, escape: /old/, timeout: 0.01)
+    refute input.pending_output?
+    assert_empty input.buffer
+    assert_equal "oldtail", peer.read_nonblock(100)
+  end
+
   def test_real_terminal_handoff_ctrl_c_escape_and_resume
     session = shell_session
     log = StringIO.new
@@ -98,6 +163,43 @@ class InteractTest < ExpectTest
     keyboard&.kill&.join if keyboard&.alive?
   end
 
+  def test_interact_preserves_newline_processing_on_the_shared_local_terminal
+    session = child(<<~'RUBY', raw_pty: true)
+      STDOUT.sync = true
+      while STDIN.gets
+        STDOUT.write("first\nsecond\r")
+        STDIN.gets
+        STDOUT.write("\nFW# ")
+      end
+    RUBY
+    master, _, source = local_terminal
+    screen = Expect.open(master, write_timeout: 3)
+    @sessions << screen
+    driver = Thread.new do
+      screen.write("show\n")
+      ScriptProbe.check(screen.expect("first\r\nsecond\r", timeout: 3),
+                        "interact disabled output newline processing")
+      screen.write("continue\n")
+      ScriptProbe.check(screen.expect("\nFW# ", timeout: 3), "interact duplicated a split CRLF sequence")
+      screen.write(InteractProbe::ESCAPE)
+      true
+    rescue Exception # rubocop:disable Lint/RescueException -- Release interact when the assertion fails.
+      begin
+        screen.write(InteractProbe::ESCAPE)
+      rescue StandardError
+        nil
+      end
+      raise
+    end
+    driver.report_on_exception = false
+
+    assert_same source, session.interact(input: source, escape: InteractProbe::ESCAPE, output: source.to_io, timeout: 5)
+    assert driver.join(2), "terminal driver did not finish"
+    assert driver.value
+  ensure
+    driver&.kill&.join if driver&.alive?
+  end
+
   def test_remote_eof_restores_input_terminal_and_keeps_borrowed_io_open
     session = child('STDIN.gets; print "FINAL_REMOTE_OUTPUT"', raw_pty: true)
     _, slave, source = local_terminal

data/test/interconnect_test.rb

@@ -3,6 +3,113 @@
 require_relative "test_helper"
 
 class InterconnectTest < ExpectTest
+  def test_escape_callback_can_match_new_input_and_return_its_tail
+    session, writer = pipe_session
+    output = StringIO.new
+    session.listeners = [output]
+    result = nil
+    session.on_sequence("!") do
+      writer.write("ready tail")
+      result = session.expect("ready", timeout: 0.05)
+      false
+    end
+    session.buffer = "!"
+
+    assert_same(session, bounded { Expect.interconnect(session, timeout: 1) })
+    assert_equal 1, result
+    assert_equal " tail", session.buffer
+    assert_empty output.string
+    Expect.interconnect(session, timeout: 0)
+    assert_equal " tail", output.string
+  end
+
+  def test_escape_callback_can_match_previously_read_tail
+    session, = pipe_session
+    result = nil
+    session.on_sequence("!") do
+      result = session.expect("ready", timeout: 0)
+      false
+    end
+    session.buffer = "!ready tail"
+
+    assert_same session, Expect.interconnect(session, timeout: 1)
+    assert_equal 1, result
+    assert_equal " tail", session.buffer
+  end
+
+  def test_callback_match_failure_returns_unconsumed_bytes_to_relay
+    session, writer = pipe_session
+    session.on_sequence("!") do
+      writer.write("\xff".b)
+      session.expect(/ready/u, timeout: 0.05)
+    end
+    session.buffer = "!prefix"
+
+    assert_raises(EncodingError) { bounded { Expect.interconnect(session, timeout: 1) } }
+    assert_equal "prefix\xff".b, session.buffer
+    assert_nil session.__send__(:interaction_buffer)
+  end
+
+  def test_timeout_flush_leaves_blocked_output_pending_without_reading_after_deadline
+    reader, writer = IO.pipe
+    sink, sink_writer = IO.pipe
+    @ios.push(reader, writer, sink, sink_writer)
+    loop { break if sink_writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
+    session = Expect.open(reader, writer: sink_writer, write_timeout: 1)
+    @sessions << session
+    # A loopback listener must not wait or read more input after the deadline.
+    session.listeners = [session]
+    session.on_sequence("STOP")
+    session.buffer = "ST"
+    writer.write("tail")
+    original = IO.method(:select)
+    poll = true
+    select = lambda do |*arguments|
+      if poll
+        poll = false
+        nil
+      else
+        original.call(*arguments)
+      end
+    end
+
+    IO.stub(:select, select) { assert_nil Expect.interconnect(session, timeout: 0) }
+    assert session.pending_output?
+    assert_empty session.buffer
+    session.listeners = []
+    assert_equal 1, session.expect("tail", timeout: 0)
+  end
+
+  def test_backpressure_reads_still_apply_escape_sequences
+    source, = pipe_session
+    reader, writer = IO.pipe
+    sink, sink_writer = IO.pipe
+    @ios.push(reader, writer, sink, sink_writer)
+    loop { break if sink_writer.write_nonblock("x" * 4096, exception: false) == :wait_writable }
+    target = Expect.open(reader, writer: sink_writer, write_timeout: 1)
+    @sessions << target
+    output = StringIO.new
+    received = Queue.new
+    target.log_to { received << true }
+    target.listeners = [output]
+    target.on_sequence("STOP")
+    source.listeners = [target]
+    source.buffer = "request"
+    writer.write("beforeSTOPtail")
+    background do
+      received.pop
+      sink.readpartial(65_536)
+    end
+
+    assert_same(target, bounded { Expect.interconnect(target, source, timeout: 0.2) })
+    assert_equal "before", output.string
+    assert_equal "tail", target.buffer
+    target.log_output = nil
+    writer.write("ready")
+    assert_equal 1, target.expect("ready", timeout: 1)
+    assert_equal "tail", target.before
+  end
+
   def test_interconnect_forwards_and_strips_split_escape
     session, writer = pipe_session
     listener = StringIO.new
@@ -102,14 +209,17 @@ class InterconnectTest < ExpectTest
     assert_equal ["original"], source.instance_variable_get(:@sequences).keys
   end
 
-  def test_terminal_modes_restore_after_callback_exception
+  def test_interconnect_leaves_terminal_modes_to_the_caller
     session = child('print "!"; sleep 30')
-    mode = session.to_io.console_mode
     original = terminal_configuration(session)
-    session.on_sequence("!") { raise "stop" }
+    seen = nil
+    session.on_sequence("!") do
+      seen = terminal_configuration(session)
+      raise "stop"
+    end
     assert_raises(RuntimeError) { Expect.interconnect(session, timeout: 1) }
+    assert_equal original, seen
     assert_equal original, terminal_configuration(session)
-    refute_nil mode
   end
 
   def test_manual_stty_leaves_terminal_mode_to_caller
@@ -136,6 +246,50 @@ class InterconnectTest < ExpectTest
     assert_empty session.buffer
   end
 
+  def test_interconnect_retries_an_interrupted_select
+    session, writer = pipe_session
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence("!")
+    writer.write("ready!")
+    original = IO.method(:select)
+    interrupted = true
+    select = lambda do |*arguments|
+      if interrupted
+        interrupted = false
+        raise Errno::EINTR
+      end
+      original.call(*arguments)
+    end
+
+    IO.stub(:select, select) do
+      assert_same session, Expect.interconnect(session, timeout: 1)
+    end
+    assert_equal "ready", output.string
+  end
+
+  def test_interconnect_retries_an_interrupted_read
+    session, writer = pipe_session
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence("!")
+    writer.write("ready!")
+    original = session.to_io.method(:read_nonblock)
+    interrupted = true
+    read = lambda do |*arguments, **options|
+      if interrupted
+        interrupted = false
+        raise Errno::EINTR
+      end
+      original.call(*arguments, **options)
+    end
+
+    session.to_io.stub(:read_nonblock, read) do
+      assert_same session, Expect.interconnect(session, timeout: 1)
+    end
+    assert_equal "ready", output.string
+  end
+
   def test_regexp_escape_matches_and_preserves_trailing_input
     session, writer = pipe_session
     output = StringIO.new
@@ -169,6 +323,36 @@ class InterconnectTest < ExpectTest
     assert_equal "after", session.buffer
   end
 
+  def test_regexp_escape_history_has_a_finite_default_window
+    session, = pipe_session
+    session.on_sequence(/UNLIKELY_ESCAPE/)
+    buffers = { session => "".b }
+
+    5.times do
+      buffers[session] << ("x" * 16_384)
+      Expect.send(:relay_buffer, session, buffers)
+    end
+
+    assert_operator session.__send__(:relay_history).bytesize, :<=, 65_536
+    assert_empty buffers.fetch(session)
+  end
+
+  def test_utf8_regexp_escape_history_keeps_a_valid_leading_character
+    session, = pipe_session
+    session.on_sequence(/终止/u)
+    buffers = { session => "".b }
+
+    6.times do
+      buffers[session] << ("中" * 5461).b
+      assert Expect.send(:relay_buffer, session, buffers)
+    end
+
+    assert_operator session.__send__(:relay_history).bytesize, :<=, 65_536
+    assert session.__send__(:relay_history).dup.force_encoding(Encoding::UTF_8).valid_encoding?
+    buffers[session] << "终止".b
+    refute Expect.send(:relay_buffer, session, buffers)
+  end
+
   def test_regexp_escape_continuation_does_not_rematch_history
     session, writer = pipe_session
     seen = []
@@ -194,6 +378,21 @@ class InterconnectTest < ExpectTest
     assert_equal "abc", session.buffer
   end
 
+  def test_log_failure_preserves_received_bytes_for_recovery
+    session, writer = pipe_session
+    session.log_to { raise IOError, "log failed" }
+    writer.write("before!tail")
+
+    error = assert_raises(IOError) { Expect.interconnect(session, timeout: 1) }
+    assert_equal "log failed", error.message
+    assert_equal "before!tail", session.buffer
+    refute session.eof?
+
+    session.log_output = nil
+    assert_equal 1, session.expect("before!", timeout: 0)
+    assert_equal "tail", session.buffer
+  end
+
   def test_logs_received_bytes_once_across_expect_interconnect_and_expect
     session, writer = pipe_session
     log = StringIO.new

data/test/io_test.rb

@@ -49,6 +49,26 @@ class IOTest < ExpectTest
     assert_equal "\ncba\n", chunks.join
   end
 
+  def test_new_log_files_are_private_without_changing_existing_permissions
+    session, = pipe_session
+    Dir.mktmpdir do |directory|
+      previous_umask = File.umask(0o022)
+      begin
+        %w[a w].each do |mode|
+          path = File.join(directory, "session-#{mode}.log")
+          session.log_to(path, mode: mode)
+          assert_equal 0o600, File.stat(path).mode & 0o777
+          session.log_output = nil
+          File.chmod(0o640, path)
+          session.log_to(path, mode: mode)
+          assert_equal 0o640, File.stat(path).mode & 0o777
+        end
+      ensure
+        File.umask(previous_umask)
+      end
+    end
+  end
+
   def test_group_and_stdout_logging_can_be_controlled_separately
     session, writer = pipe_session
     listener = StringIO.new
@@ -85,6 +105,25 @@ class IOTest < ExpectTest
     assert_match(/received "more"/, diagnostics)
   end
 
+  def test_quiet_mode_does_not_format_byte_content_for_diagnostics
+    session, peer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(session, peer)
+    connection = Expect.open(session, debug_level: 0)
+    @sessions << connection
+    inspected = 0
+    probe = TracePoint.new(:c_call) do |event|
+      inspected += 1 if event.defined_class == String && event.method_id == :inspect
+    end
+
+    probe.enable do
+      connection.write("hello")
+      peer.write("reply")
+      connection.expect("reply", timeout: 1)
+    end
+
+    assert_equal 0, inspected
+  end
+
   def test_send_slow_collects_replies_even_when_logging_disabled
     session = child("loop { char = STDIN.read(1); break unless char; print char.upcase }", raw_pty: true)
     session.log_listeners = false
@@ -121,6 +160,69 @@ class IOTest < ExpectTest
     assert_empty Expect.readable_sessions(first, second)
   end
 
+  def test_readiness_retries_an_interrupted_select
+    session, writer = pipe_session
+    writer.write("ready")
+    original = IO.method(:select)
+    interrupted = true
+    select = lambda do |*arguments|
+      if interrupted
+        interrupted = false
+        raise Errno::EINTR
+      end
+      original.call(*arguments)
+    end
+
+    IO.stub(:select, select) do
+      assert_equal [session], Expect.readable_sessions(session, timeout: 1)
+    end
+  end
+
+  def test_write_retries_an_interrupted_nonblocking_write
+    reader, writer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(reader, writer)
+    session = Expect.open(reader)
+    @sessions << session
+    original = reader.method(:write_nonblock)
+    interrupted = true
+    write = lambda do |*arguments, **options|
+      if interrupted
+        interrupted = false
+        raise Errno::EINTR
+      end
+      original.call(*arguments, **options)
+    end
+
+    reader.stub(:write_nonblock, write) do
+      assert_equal 5, session.write("hello")
+    end
+    assert_equal "hello", writer.read(5)
+  end
+
+  def test_write_retries_an_interrupted_writable_wait
+    reader, writer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(reader, writer)
+    session = Expect.open(reader, write_timeout: 1)
+    @sessions << session
+    original = reader.method(:write_nonblock)
+    waiting = true
+    write = lambda do |*arguments, **options|
+      if waiting
+        waiting = false
+        :wait_writable
+      else
+        original.call(*arguments, **options)
+      end
+    end
+
+    reader.stub(:write_nonblock, write) do
+      IO.stub(:select, ->(*) { raise Errno::EINTR }) do
+        assert_equal 5, session.write("hello")
+      end
+    end
+    assert_equal "hello", writer.read(5)
+  end
+
   def test_readiness_waits_for_data_and_does_not_consume_data
     first, = pipe_session
     second, writer = pipe_session

data/test/matching_test.rb

@@ -126,6 +126,19 @@ class MatchingTest < ExpectTest
     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)
@@ -134,6 +147,26 @@ class MatchingTest < ExpectTest
     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"

data/test/process_test.rb

@@ -36,9 +36,10 @@ class ProcessTest < ExpectTest
     assert session.slave.tty?
     session.slave.echo = false
     session.slave.winsize = [37, 111]
-    session.spawn(RbConfig.ruby, "--disable-gems", "-rio/console", "-e",
+    # 子进程需要 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)
+    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