expect-pty 0.3.2 → 0.4.0

data/test/diagnostics_test.rb

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "logger"
+
+class DiagnosticsTest < ExpectTest
+  def test_logger_receives_lifecycle_and_payload_at_separate_levels
+    session, writer = pipe_session(debug_level: 2)
+    output = StringIO.new
+    logger = Logger.new(output)
+    logger.level = Logger::INFO
+    session.diagnostic_output = logger
+    writer.write("ready")
+    session.expect("ready", timeout: 1)
+    assert_includes output.string, "matched pattern 1"
+    refute_includes output.string, "received"
+    logger.level = Logger::DEBUG
+    writer.write("next")
+    session.expect("next", timeout: 1)
+    assert_includes output.string, 'received "next"'
+    session.close
+    refute output.closed?
+  end
+
+  def test_constructor_accepts_borrowed_diagnostic_io_and_keeps_transcript_separate
+    diagnostics = StringIO.new
+    session, writer = pipe_session(debug_level: 2, diagnostic_output: diagnostics)
+    transcript = StringIO.new
+    session.log_to(transcript)
+    writer.write("ready")
+    session.expect("ready", timeout: 1)
+    assert_equal "ready", transcript.string
+    assert_includes diagnostics.string, 'received "ready"'
+    session.close
+    refute diagnostics.closed?
+    refute transcript.closed?
+  end
+
+  def test_callable_diagnostics_receive_immutable_metadata_without_the_session
+    events = []
+    session, writer = pipe_session(debug_level: 2, diagnostic_output: ->(event) { events << event })
+    writer.write("ready")
+    session.expect("ready", timeout: 1)
+    event = events.find { |item| item[:event] == :received }
+    assert event.frozen?
+    assert event[:message].frozen?
+    assert_equal :debug, event[:level]
+    assert_equal session.fileno, event[:fd]
+    assert_equal 'received "ready"', event[:message]
+    refute_includes event.values, session
+    assert_equal :info, events.last[:level]
+  end
+
+  def test_invalid_diagnostic_target_preserves_the_previous_target
+    session, = pipe_session
+    output = StringIO.new
+    session.diagnostic_output = output
+    assert_raises(ArgumentError) { session.diagnostic_output = Object.new }
+    assert_same output, session.diagnostic_output
+  end
+
+  def test_diagnostic_failure_keeps_original_input_available
+    session, writer = pipe_session(debug_level: 2)
+    failure = IOError.new("diagnostic failed")
+    session.diagnostic_output = ->(_) { raise failure }
+    writer.write("ready")
+    result = session.expect_result("ready", timeout: 1)
+    assert_same failure, result.error
+    assert_equal "ready", session.buffer
+    session.debug_level = 0
+    assert_equal 1, session.expect("ready", timeout: 0)
+  end
+
+  def test_nested_diagnostic_wait_preserves_the_outer_match_result
+    session, = pipe_session(debug_level: 1)
+    session.buffer = "ready"
+    nested = nil
+    notified = false
+    callback_result = nil
+    session.diagnostic_output = lambda do |event|
+      next unless event[:event] == :matched && !notified
+
+      notified = true
+      nested = session.expect_result("missing", timeout: 0)
+    end
+    result = session.expect_result(timeout: 0) do |patterns|
+      patterns.on("ready") { |source| callback_result = source.last_result }
+    end
+    assert nested.timeout?
+    assert result.matched?
+    assert_equal "ready", result.match
+    assert_same result, callback_result
+    assert_same result, session.last_result
+  end
+
+  def test_redaction_handles_every_two_chunk_split_and_overlapping_secrets
+    (0..11).each do |split|
+      session, = pipe_session
+      output = StringIO.new
+      session.log_to(output)
+      session.redact("abc", "bcd", "secret")
+      text = "xabcdsecret!"
+      session.write_log(text.byteslice(0, split))
+      session.write_log(text.byteslice(split..))
+      session.log_output = nil
+      assert_equal "x[FILTERED]!", output.string, "split #{split}"
+    end
+  end
+
+  def test_byte_at_a_time_redaction_preserves_matching_and_listeners
+    session, writer = pipe_session(debug_level: 3)
+    events = []
+    log = StringIO.new
+    forwarded = StringIO.new
+    session.diagnostic_output = ->(event) { events << event }
+    session.log_to(log)
+    session.listeners = [forwarded]
+    session.redact("password")
+    "password!".each_char do |byte|
+      writer.write(byte)
+      session.__send__(:read_available)
+      refute_includes log.string, "password"
+    end
+    assert_equal 1, session.expect("password!", timeout: 0)
+    writer.close
+    assert session.expect_result(:eof, timeout: 1).eof?
+    assert_equal "[FILTERED]!", log.string
+    assert_equal "password!", forwarded.string
+    received = events.select { |event| event[:event] == :received }.map { |event| event[:message] }.join
+    assert_includes received, "[FILTERED]"
+    refute_includes events.inspect, "password"
+    buffers = events.select { |event| event[:event] == :buffer }
+    assert(buffers.all? { |event| event[:message] == "buffer [FILTERED]" })
+  end
+
+  def test_sending_diagnostics_are_filtered_across_separate_writes
+    client, peer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(client, peer)
+    output = StringIO.new
+    session = Expect.open(client, debug_level: 2, diagnostic_output: output)
+    @sessions << session
+    session.redact("password")
+    %w[pa ss wo rd].each { |part| session.write(part) }
+    assert_equal "password", peer.read(8)
+    session.close
+    refute_includes output.string, "password"
+    refute_includes output.string, '"pa"'
+    assert_includes output.string, "[FILTERED]"
+  end
+
+  def test_registration_copies_secrets_is_additive_and_isolated_between_sessions
+    first, = pipe_session
+    second, = pipe_session
+    first_log = StringIO.new
+    second_log = StringIO.new
+    first.log_to(first_log)
+    second.log_to(second_log)
+    secret = +"first"
+    assert_same first, first.redact(secret)
+    secret.replace("changed")
+    first.write_log("fi")
+    first.redact("second")
+    first.write_log("rst second")
+    second.write_log("first second")
+    first.close
+    assert_equal "[FILTERED] [FILTERED]", first_log.string
+    assert_equal "first second", second_log.string
+  end
+
+  def test_binary_secrets_are_matched_before_diagnostic_escaping
+    session, = pipe_session(debug_level: 2)
+    log = StringIO.new
+    diagnostics = StringIO.new
+    session.log_to(log)
+    session.diagnostic_output = diagnostics
+    secret = "\xff\0\n".b
+    session.redact(secret)
+    session.write_log("before#{secret}after".b)
+    session.__send__(:trace_data, :received, secret, level: 2)
+    session.close
+    assert_equal "before[FILTERED]after", log.string
+    refute_includes diagnostics.string, '\\xFF'
+    assert_includes diagnostics.string, "[FILTERED]"
+  end
+
+  def test_eof_and_close_flush_benign_tails_but_hide_incomplete_secret_prefixes
+    session, writer = pipe_session
+    log = StringIO.new
+    session.log_to(log)
+    session.redact("password")
+    writer.write("hello pass")
+    writer.close
+    assert session.expect_result(:eof, timeout: 1).eof?
+    assert_equal "hello [FILTERED]", log.string
+    session.close
+    assert_equal "hello [FILTERED]", log.string
+  end
+
+  def test_replacing_log_finishes_the_original_target_and_keeps_it_borrowed
+    session, = pipe_session
+    first = StringIO.new
+    second = StringIO.new
+    session.redact("secret")
+    session.log_to(first)
+    session.write_log("hello")
+    session.log_to(second)
+    session.write_log("secret!")
+    session.close
+    assert_equal "hello", first.string
+    assert_equal "[FILTERED]!", second.string
+    refute first.closed?
+    refute second.closed?
+  end
+
+  def test_invalid_registration_does_not_partially_add_secrets
+    session, = pipe_session
+    output = StringIO.new
+    session.log_to(output)
+    [[], [""], [nil], ["valid", 42]].each do |values|
+      assert_raises(ArgumentError) { session.redact(*values) }
+    end
+    session.write_log("valid")
+    assert_equal "valid", output.string
+  end
+
+  def test_reopening_the_same_log_path_finishes_the_old_stream_before_truncating
+    session, = pipe_session
+    session.redact("password")
+    Dir.mktmpdir do |directory|
+      path = File.join(directory, "session.log")
+      previous = session.log_to(path, mode: "w")
+      session.write_log("hello")
+      assert_equal "", File.binread(path)
+      session.log_to(path, mode: "w")
+      assert previous.closed?
+      session.write_log("x")
+      session.close
+      assert_equal "x", File.binread(path)
+    end
+  end
+
+  def test_failed_old_log_flush_does_not_truncate_the_new_path
+    session, = pipe_session
+    session.redact("password")
+    failure = IOError.new("old log failed")
+    session.log_to { raise failure }
+    session.write_log("tail")
+    Dir.mktmpdir do |directory|
+      path = File.join(directory, "existing.log")
+      File.write(path, "keep")
+      assert_same failure, assert_raises(IOError) { session.log_to(path, mode: "w") }
+      assert_equal "keep", File.binread(path)
+    end
+    session.log_output = nil
+    assert_nil session.log_output
+  end
+
+  def test_flush_failure_does_not_prevent_handle_and_child_cleanup
+    session = child('puts "ready"; sleep 60', raw_pty: true)
+    session.expect("ready", timeout: 2)
+    session.redact("password")
+    failure = IOError.new("flush failed")
+    session.log_to { raise failure }
+    session.write_log("hi") # 小于保留窗口，失败应发生在关闭时的尾部交付。
+    assert_same failure, assert_raises(IOError) { session.close }
+    assert session.closed?
+    refute session.alive?
+    session.log_output = nil
+  end
+
+  def test_unexpected_diagnostic_flush_failure_still_closes_owned_log
+    session, = pipe_session(debug_level: 2)
+    session.redact("password")
+    Dir.mktmpdir do |directory|
+      log = session.log_to(File.join(directory, "session.log"))
+      failure = RuntimeError.new("diagnostic callback failed")
+      session.diagnostic_output = ->(_) { raise failure }
+      session.__send__(:trace_data, :sending, "hi", level: 2)
+      assert_same failure, assert_raises(RuntimeError) { session.close }
+      assert log.closed?
+      assert session.closed?
+    end
+  end
+
+  def test_replacing_diagnostics_finishes_the_previous_stream
+    session, = pipe_session(debug_level: 2)
+    session.redact("password")
+    first = StringIO.new
+    second = StringIO.new
+    session.diagnostic_output = first
+    session.__send__(:trace_data, :received, "pass", level: 2)
+    session.diagnostic_output = second
+    session.__send__(:trace_data, :received, "password!", level: 2)
+    session.close
+    assert_includes first.string, "[FILTERED]"
+    refute_includes first.string, "pass"
+    assert_includes second.string, "[FILTERED]"
+    refute_includes second.string, "password"
+    refute first.closed?
+    refute second.closed?
+  end
+
+  def test_log_callback_can_rotate_the_target_during_close
+    session, = pipe_session
+    session.redact("long-secret")
+    delivered = []
+    rotated = nil
+    Dir.mktmpdir do |directory|
+      path = File.join(directory, "rotated.log")
+      session.log_to do |data|
+        delivered << data
+        rotated = session.log_to(path, mode: "w")
+        session.write_log("body")
+      end
+      session.write_log("xyz")
+      session.close
+      assert_equal ["xyz"], delivered
+      assert rotated.closed?
+      assert_equal "body", File.binread(path)
+      assert_nil session.log_output
+    end
+  end
+
+  def test_diagnostic_flush_callback_can_create_or_revisit_the_other_direction
+    [nil, "seed"].each do |initial_send|
+      client, peer = Socket.pair(:UNIX, :STREAM, 0)
+      @ios.push(client, peer)
+      session = Expect.open(client, debug_level: 2)
+      @sessions << session
+      session.redact("long-secret")
+      events = []
+      session.diagnostic_output = lambda do |event|
+        events << event
+        session.write("ack") if event[:event] == :received
+      end
+      if initial_send
+        session.write(initial_send)
+        assert_equal initial_send, peer.read(initial_send.bytesize)
+      end
+      peer.write("xyz")
+      assert_equal 1, session.expect("xyz", timeout: 0)
+      replacement = StringIO.new
+      session.diagnostic_output = replacement
+      assert_equal "ack", peer.read(3)
+      expected = initial_send ? %i[matched sending received sending] : %i[matched received sending]
+      assert_equal(expected, events.map { |event| event[:event] })
+      assert_includes events.last[:message], "ack"
+      assert_equal "", replacement.string
+      session.close
+      assert_equal "", replacement.string
+    end
+  end
+end

data/test/lifecycle_contract_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class LifecycleContractTest < ExpectTest
+  def test_external_reaping_releases_pid_without_fabricating_process_status
+    session = child('puts "ready"; exit 7', raw_pty: true)
+    assert_equal 1, session.expect("ready", timeout: 2)
+    pid = session.pid
+    assert_equal(7, bounded { Process.waitpid2(pid).last.exitstatus })
+    refute session.alive?
+    assert_nil session.pid
+    assert_nil session.process_status
+    assert_nil session.wait(timeout: 0)
+    Process.stub(:kill, ->(*) { flunk "must not signal an externally reaped PID" }) do
+      2.times { session.close }
+    end
+    assert session.closed?
+  end
+
+  def test_external_reader_close_does_not_take_ownership_of_the_writer
+    reader, producer = IO.pipe
+    consumer, writer = IO.pipe
+    @ios.push(reader, producer, consumer, writer)
+    session = Expect.open(reader, writer: writer)
+    @sessions << session
+    session.buffer = "tail"
+    reader.close
+    assert session.closed?
+    assert session.eof?
+    refute session.alive?
+    assert_raises(IOError) { session.write("blocked") }
+    2.times { session.close }
+    refute writer.closed?
+    assert_equal "tail", session.buffer
+    writer.write("borrowed")
+    assert_equal "borrowed", consumer.read(8)
+  end
+
+  def test_failed_handle_close_can_be_retried_without_losing_other_owned_handles
+    reader, writer = IO.pipe
+    @ios.push(reader, writer)
+    session = Expect.open(reader, writer: writer, own: true)
+    @sessions << session
+    failure = IOError.new("close failed")
+    reader.stub(:close, -> { raise failure }) do
+      assert_same failure, assert_raises(IOError) { session.close }
+      assert writer.closed?
+      refute reader.closed?
+      assert session.closed?
+    end
+    session.close
+    assert reader.closed?
+    assert_nil session.close
+  end
+
+  def test_timeout_and_eof_remain_events_and_write_errors_remain_io_errors
+    session, writer = pipe_session
+    timeout = session.expect_result("missing", timeout: 0)
+    assert timeout.timeout?
+    assert_equal :timeout, timeout.error
+    writer.close
+    eof = session.expect_result(:eof, timeout: 1)
+    assert eof.eof?
+    assert_equal :eof, eof.error
+    failure = Expect::WriteTimeout.new(bytes_written: 3)
+    assert_kind_of IOError, failure
+    assert_equal 3, failure.bytes_written
+    assert_operator Expect::SpawnError, :<, StandardError
+  end
+end

data/test/literal_scan_test.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class LiteralScanTest < ExpectTest
+  def test_new_bytes_can_complete_a_previously_missing_literal
+    session, writer = pipe_session
+    list = Expect::PatternList.new([session], ["password:", "word:"])
+    matcher = Expect::Matcher.new(list, nil)
+    session.buffer = "prefix pass"
+    assert_nil matcher.__send__(:find_match)
+    writer.write("word:")
+    session.__send__(:read_available)
+    result = matcher.__send__(:find_match)
+    assert_equal 1, result[1].number
+    assert_equal [7, 9, []], result[2]
+  end
+
+  def test_later_text_for_an_earlier_pattern_keeps_declaration_priority
+    session, writer = pipe_session
+    list = Expect::PatternList.new([session], %w[preferred ready])
+    matcher = Expect::Matcher.new(list, nil)
+    session.buffer = "ready"
+    assert_equal 2, matcher.__send__(:find_match)[1].number
+    writer.write(" preferred")
+    session.__send__(:read_available)
+    assert_equal 1, matcher.__send__(:find_match)[1].number
+  end
+
+  def test_destructive_buffer_changes_invalidate_old_misses
+    session, writer = pipe_session
+    list = Expect::PatternList.new([session], ["start", "token", /END/])
+    matcher = Expect::Matcher.new(list, nil)
+    session.buffer = "x" * 100
+    assert_nil matcher.__send__(:find_match)
+    session.buffer = "start"
+    assert_equal 1, matcher.__send__(:find_match)[1].number
+    session.clear_buffer
+    assert_nil matcher.__send__(:find_match)
+    writer.write("token")
+    session.__send__(:read_available)
+    assert_equal 2, matcher.__send__(:find_match)[1].number
+    session.expect("token", timeout: 0)
+    session.buffer_limit = 8
+    writer.write("xxxxstart")
+    session.__send__(:read_available)
+    assert_equal [3, 5, []], matcher.__send__(:find_match)[2]
+    session.clear_buffer
+    session.__send__(:restore_relay_buffer, "token")
+    assert_equal 2, matcher.__send__(:find_match)[1].number
+  end
+
+  def test_repeated_scans_equal_a_fresh_matcher_across_operation_sequences
+    session, writer = pipe_session
+    patterns = ["abc", "bc", "\0\xff".b, /END/n]
+    list = Expect::PatternList.new([session], patterns)
+    matcher = Expect::Matcher.new(list, nil)
+    random = Random.new(40_033)
+    chunks = ["a", "b", "c", "x", "END", "\0", "\xff".b]
+    150.times do
+      case random.rand(6)
+      when 0
+        session.buffer = chunks.sample(random: random) * random.rand(1..4)
+      when 1
+        session.clear_buffer
+      when 2
+        session.buffer_limit = [nil, 2, 5, 12].sample(random: random)
+      when 3
+        session.__send__(:restore_relay_buffer, chunks.sample(random: random).b)
+      when 4
+        session.expect("x", timeout: 0)
+      else
+        writer.write(chunks.sample(random: random))
+        session.__send__(:read_available)
+      end
+      expected = Expect::Matcher.new(list, nil).__send__(:find_match)
+      actual = matcher.__send__(:find_match)
+      assert_equal signature(expected), signature(actual), "buffer=#{session.buffer.inspect}"
+    end
+  end
+
+  def test_a_dynamically_registered_pattern_is_scanned_from_the_start
+    session, = pipe_session
+    session.buffer = "prefix ready"
+    list = Expect::PatternList.new([session], ["missing"])
+    matcher = Expect::Matcher.new(list, nil)
+    assert_nil matcher.__send__(:find_match)
+    list.on("prefix")
+    assert_equal [0, 6, []], matcher.__send__(:find_match)[2]
+  end
+
+  private
+
+  def signature(result)
+    result ? [result[0], result[1].number, result[2]] : []
+  end
+end

data/test/pattern_offset_test.rb

@@ -16,8 +16,10 @@ class PatternOffsetTest < ExpectTest
     ]
     session, = pipe_session
     cases.each do |text, regexp, offset, length, captures|
-      bytes = text.b
+      # 扫描只读调用者输入；省去正则副本后也不能改变编码标记或冻结字符串。
+      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

data/test/process_test.rb

@@ -77,6 +77,14 @@ class ProcessTest < ExpectTest
     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
@@ -228,6 +236,17 @@ class ProcessTest < ExpectTest
     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
@@ -242,4 +261,31 @@ class ProcessTest < ExpectTest
     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