expect-pty 0.3.3 → 0.5.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/redactor_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "open3"
+require "rbconfig"
+require_relative "../lib/expect/redactor"
+
+class RedactorTest < Minitest::Test
+  def test_standalone_require_does_not_load_pty_or_allocate_a_session
+    program = <<~RUBY
+      require "expect/redactor"
+      abort "PTY loaded" if defined?(PTY)
+      abort "unexpected result" unless Expect::Redactor.redact("secret!", ["secret"]) == "[FILTERED]!"
+    RUBY
+    output, status = Open3.capture2e(RbConfig.ruby, "--disable-gems", "-I", File.expand_path("../lib", __dir__),
+                                     "-e", program)
+    assert status.success?, output
+  end
+
+  def test_empty_patterns_pass_binary_input_without_buffering
+    filter = Expect::Redactor.new([])
+    assert_equal "\xff\0raw".b, filter.append("\xff\0raw".b)
+    assert_empty filter.finish
+    assert_equal "plain", Expect::Redactor.redact("plain", [])
+  end
+
+  def test_one_shot_redaction_does_not_treat_an_ordinary_suffix_as_a_secret_prefix
+    assert_equal "pass", Expect::Redactor.redact("pass", ["password"])
+    assert_equal "[REDACTED]!", Expect::Redactor.redact("password!", ["password"], replacement: "[REDACTED]")
+  end
+
+  def test_stream_finish_masks_partial_secrets_by_default
+    filter = Expect::Redactor.new(["password"])
+    assert_equal "prefix [FILTERED]", filter.append("prefix pass") + filter.finish
+    assert_empty filter.finish
+    assert_equal "[FILTERED]!", filter.append("password!") + filter.finish
+  end
+
+  def test_exact_finish_is_explicit_and_validated
+    filter = Expect::Redactor.new(["password"])
+    filter.append("pass")
+    assert_raises(ArgumentError) { filter.finish(partial: nil) }
+    assert_equal "pass", filter.finish(partial: false)
+  end
+
+  def test_custom_marker_and_overlapping_patterns_at_every_boundary
+    patterns = ["alpha[REDACTED]omega", "[REDACTED]", "REDACTED", "[", "abc", "cde"]
+    input = "alpha[REDACTED]omega | [REDACTED] | abcde!"
+    expected = "[REDACTED] | [REDACTED] | [REDACTED]!"
+    (0..input.bytesize).each do |split|
+      filter = Expect::Redactor.new(patterns, replacement: "[REDACTED]")
+      actual = filter.append(input.byteslice(0, split)) + filter.append(input.byteslice(split..)) + filter.finish
+      assert_equal expected, actual, "split #{split}"
+    end
+    filter = Expect::Redactor.new(patterns, replacement: "[REDACTED]")
+    actual = input.bytes.map { |byte| filter.append(byte.chr) }.join + filter.finish
+    assert_equal expected, actual
+    assert_equal expected, Expect::Redactor.redact(input, patterns, replacement: "[REDACTED]")
+  end
+
+  def test_patterns_and_replacement_are_copied
+    secret = +"secret"
+    patterns = [secret]
+    replacement = +"hidden"
+    filter = Expect::Redactor.new(patterns, replacement: replacement)
+    secret.replace("public")
+    patterns.clear
+    replacement.clear
+    assert_equal "hidden!", filter.append("secret!") + filter.finish
+  end
+
+  def test_invalid_pattern_update_is_atomic_and_preserves_pending_data
+    filter = Expect::Redactor.new(["secret"])
+    filter.append("sec")
+    [nil, "secret", [""], ["valid", 1]].each do |patterns|
+      assert_raises(ArgumentError) { filter.patterns = patterns }
+    end
+    assert_equal "[FILTERED]!", filter.append("ret!") + filter.finish
+  end
+
+  def test_pattern_update_keeps_hidden_spans_and_matches_new_secret_across_chunks
+    filter = Expect::Redactor.new(%w[abc long-pattern])
+    filter.append("abcsec")
+    filter.patterns = ["secret"]
+    assert_equal "[FILTERED]!", filter.append("ret!") + filter.finish
+    filter.patterns = []
+    assert_equal "secret", filter.append("secret")
+    assert_empty filter.finish
+  end
+
+  def test_invalid_input_and_replacement_do_not_mutate_stream
+    [nil, "", 3].each do |replacement|
+      assert_raises(ArgumentError) { Expect::Redactor.new([], replacement: replacement) }
+    end
+    filter = Expect::Redactor.new(["secret"])
+    filter.append("sec")
+    assert_raises(ArgumentError) { filter.append(nil) }
+    assert_equal "[FILTERED]!", filter.append("ret!") + filter.finish
+  end
+
+  def test_inspect_does_not_expose_registered_or_pending_bytes
+    filter = Expect::Redactor.new(["private-pattern"])
+    filter.append("raw-pending")
+    assert_equal "#<Expect::Redactor>", filter.inspect
+  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.5.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,10 +163,13 @@ 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
 - test/process_test.rb
+- test/redactor_test.rb
 - test/relay_recovery_test.rb
 - test/release_test.rb
 - test/ruby_api_test.rb