expect-pty 0.3.3 → 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expect-pty
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - expect-pty contributors
@@ -112,6 +112,7 @@ files:
 - Rakefile
 - benchmark/matching.rb
 - benchmark/relay.rb
+- benchmark/scaling.rb
 - benchmark/send_slow.rb
 - benchmark/support.rb
 - docs/COMPATIBILITY.md
@@ -135,6 +136,7 @@ files:
 - lib/expect/pattern.rb
 - lib/expect/pattern_list.rb
 - lib/expect/pty.rb
+- lib/expect/redactor.rb
 - lib/expect/relay.rb
 - lib/expect/relay_writer.rb
 - lib/expect/result.rb
@@ -143,9 +145,12 @@ files:
 - lib/expect/version.rb
 - script/ci
 - script/release.rb
+- test/buffer_accounting_test.rb
 - test/cleanup_test.rb
 - test/compare_upstream.rb
 - test/configuration_test.rb
+- test/deadline_test.rb
+- test/diagnostics_test.rb
 - test/edge_case_test.rb
 - test/fixtures/ssh_scripts/01_identity.sh
 - test/fixtures/ssh_scripts/02_output.sh
@@ -158,6 +163,8 @@ files:
 - test/interconnect_test.rb
 - test/io_test.rb
 - test/kibitz_test.rb
+- test/lifecycle_contract_test.rb
+- test/literal_scan_test.rb
 - test/matching_test.rb
 - test/multi_session_test.rb
 - test/pattern_offset_test.rb