expect-pty 0.5.3 → 0.6.1

data/test/initialization_failure_test.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-require "minitest/mock"
-
-class InitializationFailureTest < ExpectTest
-  def test_new_closes_both_pty_ends_before_propagating_the_original_exception
-    initialization_errors.each do |failure|
-      master, slave = PTY.open
-      @ios.push(master, slave)
-      PTY.stub(:open, [master, slave]) do
-        without_ledger(failure) do
-          assert_same failure, assert_raises(failure.class) { Expect.new }
-          assert master.closed?, "master leaked before test cleanup"
-          assert slave.closed?, "slave leaked before test cleanup"
-        end
-      end
-    end
-  end
-
-  def test_open_cleans_owned_handles_and_preserves_borrowed_handles
-    [true, false].product(initialization_errors).each do |own, failure|
-      reader, writer = IO.pipe
-      @ios.push(reader, writer)
-      without_ledger(failure) do
-        assert_same failure, assert_raises(failure.class) { Expect.open(reader, writer: writer, own: own) }
-        assert_equal own, reader.closed?
-        assert_equal own, writer.closed?
-      end
-    end
-  end
-
-  def test_duplicate_owned_handle_is_attempted_once_even_when_close_fails
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    calls = 0
-    reader.stub(:close, lambda {
-      calls += 1
-      raise IOError, "injected close failure"
-    }) do
-      without_ledger(failure = Interrupt.new) do
-        assert_same failure, assert_raises(Interrupt) { Expect.open(reader, own: true) }
-        assert_equal 1, calls
-      end
-    end
-  end
-
-  def test_cleanup_failure_still_attempts_other_handles_and_keeps_primary_exception
-    initialization_errors.each do |failure|
-      reader, writer = IO.pipe
-      @ios.push(reader, writer)
-      reader.stub(:close, -> { raise Errno::EIO }) do
-        without_ledger(failure) do
-          assert_same failure, assert_raises(failure.class) { Expect.open(reader, writer: writer, own: true) }
-          assert writer.closed?
-        end
-      end
-    end
-  end
-
-  def test_new_cleanup_failure_still_closes_slave
-    master, slave = PTY.open
-    @ios.push(master, slave)
-    PTY.stub(:open, [master, slave]) do
-      master.stub(:close, -> { raise IOError, "injected close failure" }) do
-        without_ledger(failure = SystemExit.new(17)) do
-          assert_same failure, assert_raises(SystemExit) { Expect.new }
-          assert slave.closed?
-        end
-      end
-    end
-  end
-
-  def test_invalid_non_io_argument_is_not_closed_by_the_fallback
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    invalid = Object.new
-    invalid.define_singleton_method(:close) { raise "must not close non-IO objects" }
-    without_ledger(failure = Interrupt.new) do
-      assert_same failure, assert_raises(Interrupt) { Expect.open(invalid, writer: writer, own: true) }
-      assert writer.closed?
-    end
-  end
-
-  private
-
-  def initialization_errors = [Interrupt.new("injected initialization interruption"), SystemExit.new(17)]
-
-  def without_ledger(failure, &)
-    Expect::SessionResources.stub(:new, ->(*, **) { raise failure }, &)
-  end
-end

data/test/integration/README.md

@@ -1,109 +0,0 @@
-# SSH 多脚本和日志验证
-
-在仓库根目录运行，要求 Ruby 3.2+、SSH 服务，以及能运行 POSIX `/bin/sh` 的目标账户：
-
-```sh
-SSH_HOST=127.0.0.1 SSH_USER=crate ruby test/integration/ssh_scripts.rb
-# 也可以通过 Rake：
-SSH_HOST=127.0.0.1 SSH_USER=crate bundle exec rake test:ssh
-```
-
-脚本隐藏读取密码；也支持由运行环境提供 `EXPECT_PASSWORD`。密码不会作为 SSH 命令行参数传递，日志在认证完成后才开启。默认自动测试不连接
-SSH、不读取密码。
-
-支持 `SSH_PORT`（默认 22）、`EXPECT_LOG_DIR`（日志根目录）、`SSH_KNOWN_HOSTS`。连接非本机主机时，必须提供已有的受信任
-known_hosts，例如：
-
-```sh
-SSH_HOST=192.0.2.10 SSH_USER=operator SSH_PORT=22 \
-  SSH_KNOWN_HOSTS="$HOME/.ssh/known_hosts" \
-  EXPECT_LOG_DIR=tmp/device-check ruby test/integration/ssh_scripts.rb
-```
-
-这是 POSIX shell 脚本测试；厂商专用 CLI（如交换机的 `show` 命令、分页提示符）需要对应设备的命令和预期输出，不能直接使用这些
-shell fixtures。
-
-## 同一个登录会话执行的脚本
-
-| 脚本             | 验证内容                              | 预期退出码    |
-|------------------|---------------------------------------|---------------|
-| `01_identity.sh` | 当前用户、远端 PTY、完成标记          | 0             |
-| `02_output.sh`   | stdout、stderr、中文和输出顺序        | 0             |
-| `03_delayed.sh`  | 分三次延迟输出，确保日志完整          | 0             |
-| `04_failure.sh`  | 明确输出错误并退出                    | 7（预期失败） |
-| `05_recovery.sh` | 上个脚本失败后继续执行，计算结果为 42 | 0             |
-
-fixtures 位于 `test/fixtures/ssh_scripts/`，都不修改目标文件或设备配置。文件内容通过 SSH 的交互 shell 传给独立
-`/bin/sh -c` 执行，不需要上传文件。每个脚本都有随机开始/结束标记，结束标记携带真实 `$?`；脚本输出和退出码都必须符合预期才算通过。
-
-测试关闭终端回显和 shell 行编辑，使用单引号传输完整脚本，保留中文 UTF-8 和引号，避免 C locale 的交互式 readline
-把高位字节当快捷键执行。末尾仍等待 shell 提示符，确认可以继续执行下一项。
-
-另外执行两条日志控制命令：关闭日志后输出 `UNLOGGED_OUTPUT`，再以默认追加模式开启日志并输出 `APPEND_OK`。最后发送延迟输出及退出命令，只调用
-`soft_close`，确认 `SESSION_FINAL_TAIL` 确实在关闭过程中写入日志。
-
-## 检查和输出文件
-
-每次执行在 `tmp/ssh-logs/` 下创建独立目录，目录权限 0700，文件权限 0600：
-
-- `session.log`：收到的原始数据，以及手工添加的 `[SEND] 脚本名 sha256=...` 和 `[EXIT] 脚本名 status=...`。
-- `report.json`：主机、用户、远端 TTY、每项脚本输出和退出码、校验结果、SSH 退出码、日志字节数及 SHA-256。
-
-只有认证后的输出进入日志。Expect 自动记录接收字节，发送的脚本名称和摘要由 `write_log` 明确写入，便于审核执行了哪个
-fixture；fixture 文件中的原文可以用报告内的 SHA-256 核对。
-
-共 11 项日志/流程检查：完整输出、执行顺序、即时
-flush、stdout/stderr、UTF-8、非零退出后恢复、覆盖模式、暂停记录、追加模式、关闭前尾部输出、密码不出现在日志中。另校验日志条目没有重复，日志句柄在停止记录和关闭会话后正确关闭。
-
-成功返回进程退出码 0。认证失败、超时、脚本输出错误、意外退出码或日志校验失败均返回非零，并在有报告目录时留下 `passed: false`
-的报告。不用仅看到终端输出就判断成功；请查看最终 PASS 和 `report.json` 的 `passed`。
-
-## 无需 SSH 的回归测试
-
-```sh
-bundle exec ruby -Itest test/script_logging_test.rb
-bundle exec rake test
-```
-
-`test/script_logging_test.rb` 使用真实本地 PTY 执行相同 fixtures，另外验证回调日志、借用 File 日志、错误退出/错误输出的反例、引号和
-shell 元字符、日志错误上抛，以及超时后继续收集日志。它和 SSH 脚本共享测试 helper，不依赖远端账户。
-
-## SSH interact 人工和自动验证
-
-```sh
-ruby examples/ssh_interact.rb
-ruby examples/ssh_interact.rb --auto
-# 自动方式也可通过 Rake 运行
-bundle exec rake test:ssh_interact
-```
-
-使用上述同一套 SSH 环境变量和隐藏密码输入。人工模式显示 `EXPECT_SCRIPT_PROMPT>`；输入命令有回显，Ctrl-C 传给远端前台任务。在命令结束、回到
-shell 提示符后按 Ctrl-]，会关闭远端回显，执行 `MANUAL_AUTOMATION_RESUMED` 检查，再正常退出 SSH。也支持直接输入 `exit`：成功退出记为
-`completion: remote_exit`，此路径不执行返回 expect 的检查。非零 SSH 退出仍判为失败。
-
-`--auto` 创建真实本地 PTY，验证两次 `interact` 接管、当前用户和远端 TTY、stdout/stderr/中文、Ctrl-C、Ctrl-]、转义后的本地尾部不进入
-SSH、恢复 `expect` 及终端与监听设置。4 项命令输出和 13 项交互/日志检查全部通过后才返回 0。
-
-日志在认证之后开启；每次在 `tmp/ssh-interact/` 新建 0700 目录，保存 0600 的 `session.log` 和 `report.json`
-。报告包含检查项、命令输出、SSH 退出码及日志摘要。自动模式也校验日志无重复、退出尾部不丢失、密码不出现在日志中。
-
-无需 SSH 的回归位于 `test/interact_test.rb`，覆盖可见输入、Ctrl-C、两次接管、返回自动命令、超时、两端 EOF、回调异常和输出 IO
-故障时的终端恢复。`test/script_logging_test.rb` 另验证 CRLF 输出边界，包括空输出、末尾有/无换行和多个换行。
-
-## `ssh_auto.rb` 环境检查
-
-```sh
-ruby examples/ssh_auto.rb
-# 无人值守执行（密码可以由运行环境提供 EXPECT_PASSWORD）
-ruby examples/ssh_auto.rb --no-interact
-# 或执行 Rake 的自动退出入口
-bundle exec rake test:ssh_auto
-```
-
-该示例自动登录 `SSH_HOST`（默认 `127.0.0.1`），用本库的 `write` / `expect` 顺序执行文件顶部的 `COMMANDS`，显示真实输出并检查退出码。默认命令为
-`id`、`uname -srm`、`sw_vers`、`df -h /` 和 `uptime`，不修改系统设置；可直接修改数组来下发其他 macOS/POSIX shell 命令。它不依赖
-`test/support`，`ScriptProbe.check` 只供测试脚本使用。
-
-执行成功后默认进入 `interact`，输入有回显，Ctrl-C 发给远端前台任务；`exit` 或 Ctrl-] 结束连接。使用 `--no-interact` 则执行完退出。
-`EXPECT_LOG_DIR` 可指定日志目录，默认 `tmp/ssh-auto/`；每次创建独立 0600 日志，记录命令和远端输出，认证前关闭日志。此使用示例不生成
-JSON 测试报告，详细日志断言仍由 `ssh_scripts.rb` 和 `ssh_interact.rb --auto` 验证。

data/test/integration/ssh_scripts.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-# Opt-in: this script makes a real SSH connection. The default rake test does
-# not load it, and no password belongs in fixture files or command arguments.
-require "io/console"
-require "json"
-require "fileutils"
-require "tmpdir"
-require "time"
-require_relative "../support/script_probe"
-
-host = ENV.fetch("SSH_HOST", "127.0.0.1")
-user = ENV.fetch("SSH_USER", ENV.fetch("USER", "crate"))
-port = Integer(ENV.fetch("SSH_PORT", "22"), 10)
-ScriptProbe.check((1..65_535).cover?(port), "SSH_PORT must be between 1 and 65535")
-ScriptProbe.check([host, user].none? do |value|
-  value.empty? || value.start_with?("-") || value.match?(/[\s\x00]/)
-end, "invalid SSH host or user")
-known_hosts = ENV.fetch("SSH_KNOWN_HOSTS", nil)
-ScriptProbe.check(known_hosts || %w[127.0.0.1 ::1 localhost].include?(host),
-                  "SSH_KNOWN_HOSTS is required for remote hosts")
-
-password = ENV.delete("EXPECT_PASSWORD")&.dup
-unless password
-  $stderr.print("SSH password: ")
-  password = ($stdin.tty? ? $stdin.noecho(&:gets) : $stdin.gets)&.chomp
-  $stderr.puts
-end
-ScriptProbe.check(password && !password.empty? && !password.match?(/[\r\n\x00]/), "a single-line password is required")
-
-base = File.expand_path(ENV.fetch("EXPECT_LOG_DIR", File.expand_path("../../tmp/ssh-logs", __dir__)))
-FileUtils.mkdir_p(base)
-directory = Dir.mktmpdir("#{Time.now.utc.strftime("%Y%m%dT%H%M%SZ")}-", base)
-log_path = File.join(directory, "session.log")
-report_path = File.join(directory, "report.json")
-report = { host: host, port: port, user: user, started_at: Time.now.utc.iso8601, passed: false }
-runner = nil
-session = nil
-
-begin
-  Dir.mktmpdir("expect-known-hosts-") do |temporary|
-    policy = known_hosts ? "yes" : "accept-new"
-    hosts_path = known_hosts || File.join(temporary, "known_hosts")
-    args = ["ssh", "-F", "/dev/null", "-tt", "-p", port.to_s,
-            "-o", "ConnectTimeout=5", "-o", "NumberOfPasswordPrompts=1",
-            "-o", "PreferredAuthentications=password", "-o", "PubkeyAuthentication=no",
-            "-o", "StrictHostKeyChecking=#{policy}", "-o", "UserKnownHostsFile=#{hosts_path}",
-            "-l", user, host, "env ENV= PS1=#{Shellwords.escape(ScriptProbe::PROMPT)} /bin/sh -i"]
-    # Authentication is completed before opening any log. Parent defaults
-    # cannot accidentally turn on debug or console logging for this check.
-    session = Expect.spawn(*args, raw_pty: true, log_stdout: false, log_listeners: false,
-                                  debug_level: 0, write_timeout: 5)
-    authentication = session.expect_result(/password:\s*\z/i, /Permission denied/i, timeout: 10)
-    ScriptProbe.check(authentication.number == 1,
-                      "SSH password prompt not received (#{authentication.error || "authentication rejected"})")
-    session.write(password, "\n")
-    runner = ScriptProbe::Runner.new(session, timeout: 10).ready!
-    report.merge!(ScriptProbe.verify_file_session(runner, log_path, user: user))
-    report[:ssh_exit_code] = session.exit_code
-    ScriptProbe.check(!File.binread(log_path).include?(password.b), "password detected in session log")
-    report[:checks] << "password_absent"
-    report[:passed] = true
-  end
-rescue StandardError => error
-  # Error messages identify the failed check; raw authentication output is
-  # deliberately excluded from both the report and the console.
-  report[:error] = "#{error.class}: #{error.message}".gsub(password, "[REDACTED]")
-  report[:cases] ||= runner&.results || []
-ensure
-  session&.close
-  if File.file?(log_path)
-    bytes = File.binread(log_path)
-    if bytes.include?(password.b)
-      File.binwrite(log_path, bytes.gsub(password.b, "[REDACTED]"))
-      report[:passed] = false
-      report[:error] = "password detected and removed from log"
-    end
-    report[:log_sha256] = Digest::SHA256.file(log_path).hexdigest
-    report[:log_bytes] = File.size(log_path)
-  end
-  password.replace("\0" * password.bytesize)
-  report[:finished_at] = Time.now.utc.iso8601
-  report[:log_path] = log_path
-  File.open(report_path, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |file| file.write(JSON.pretty_generate(report)) }
-end
-
-report.fetch(:cases, []).each do |result|
-  puts "#{result[:passed] ? "PASS" : "FAIL"} #{result[:name]} " \
-       "exit=#{result[:status]} expected=#{result[:expected_status]}"
-end
-puts "Log: #{log_path}"
-puts "Report: #{report_path}"
-abort(report[:error]) unless report[:passed]
-puts "PASS SSH multi-script execution and #{report[:checks].length} logging checks; SSH exit=0"

data/test/interact_test.rb

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-require_relative "support/interact_probe"
-require "etc"
-
-class InteractTest < ExpectTest
-  def shell_session
-    session = Expect.spawn("/bin/sh", "-i", env: { "PS1" => ScriptProbe::PROMPT, "ENV" => nil, "LC_ALL" => "C" },
-                                            raw_pty: true, log_stdout: false, write_timeout: 3)
-    @sessions << session
-    ScriptProbe::Runner.new(session).ready!
-    InteractProbe.prepare(session)
-    # Unlike SSH, the simulated remote shell shares the transport's PTY.
-    # Keep its canonical/ISIG settings while interact raws the local keyboard.
-    session.raw_terminal = false
-    session
-  end
-
-  def local_terminal
-    master, slave = PTY.open
-    @ios.push(master, slave)
-    source = Expect.open(slave)
-    @sessions << source
-    [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
-    session.log_to(log)
-    report = bounded(20) { InteractProbe.verify(session, user: Etc.getpwuid.name) }
-    assert_equal 4, report[:cases].length
-    assert(report[:cases].all? { |result| result[:passed] })
-    assert report[:local_terminal_restored]
-    assert report[:transport_terminal_restored]
-    text = ScriptProbe.normalize(log.string)
-    %w[AUTOMATION_RESUMED SECOND_HANDOFF_OK STDOUT_FIRST STDERR_SECOND].each do |line|
-      assert_equal 1, text.scan(/^#{line}$/).length
-    end
-    refute_includes text, InteractProbe::TAIL
-  end
-
-  def test_timeout_restores_local_tty_and_session_settings
-    session = shell_session
-    _, slave, source = local_terminal
-    saved = InteractProbe.configuration(source)
-    state = InteractProbe.settings(session)
-    source.on_sequence("original")
-    source_state = InteractProbe.settings(source)
-    assert_nil session.interact(input: source, escape: "\x1d", output: slave, timeout: 0.02)
-    assert_equal saved, InteractProbe.configuration(source)
-    assert_equal state, InteractProbe.settings(session)
-    assert_equal source_state, InteractProbe.settings(source)
-    assert session.alive?
-  end
-
-  def test_manual_typing_is_visible_before_enter_and_automation_resumes_without_echo
-    session = shell_session
-    InteractProbe.prepare(session, echo: true)
-    master, slave, source = local_terminal
-    screen = Expect.open(master, write_timeout: 3)
-    @sessions << screen
-    saved = InteractProbe.configuration(source)
-    session.write("printf '\\n%s\\n' 'MANUAL_READY'\n")
-    keyboard = Thread.new do
-      ScriptProbe.check(screen.expect(/\r?\nMANUAL_READY\r?\n/, timeout: 3), "manual handoff was not ready")
-      ScriptProbe.check(screen.expect(ScriptProbe::PROMPT, timeout: 3), "manual prompt missing")
-      command = "printf 'VISIBLE_COMMAND\\n'"
-      screen.write(command)
-      ScriptProbe.check(screen.expect(command, timeout: 3), "typed command was invisible before Enter")
-      screen.write("\n")
-      ScriptProbe.check(screen.expect(/\r?\nVISIBLE_COMMAND\r?\n/, timeout: 3), "manual command output missing")
-      ScriptProbe.check(screen.expect(ScriptProbe::PROMPT, timeout: 3), "manual command did not return to shell")
-      screen.write(InteractProbe::ESCAPE)
-      true
-    rescue Exception # rubocop:disable Lint/RescueException -- Clean up terminal drivers even on Interrupt or SystemExit.
-      begin
-        screen.write(InteractProbe::ESCAPE)
-      rescue StandardError
-        nil
-      end
-      raise
-    end
-    keyboard.report_on_exception = false
-    assert_same source, session.interact(input: source, escape: InteractProbe::ESCAPE, output: slave, timeout: 12)
-    assert keyboard.join(2), "manual keyboard driver did not finish"
-    assert keyboard.value
-    assert_equal saved, InteractProbe.configuration(source)
-    InteractProbe.prepare(session)
-    log = StringIO.new
-    session.log_to(log)
-    result = ScriptProbe::Runner.new(session).run("manual_resume", "printf 'RESUMED_WITHOUT_ECHO\\n'",
-                                                  expected_status: 0, expected_output: "RESUMED_WITHOUT_ECHO\n")
-    assert result[:passed]
-    refute_includes log.string, "printf"
-  ensure
-    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
-    saved = InteractProbe.configuration(source)
-    output = StringIO.new
-    session.write("go\n")
-    assert_same session, session.interact(input: source, escape: "\x1d", output: output, timeout: 3)
-    assert_equal "FINAL_REMOTE_OUTPUT", output.string
-    assert_equal saved, InteractProbe.configuration(source)
-    refute slave.closed?
-    assert_equal 0, session.wait(timeout: 1).exitstatus
-  end
-
-  def test_local_eof_returns_without_closing_remote_session
-    session = shell_session
-    source, writer = pipe_session
-    writer.close
-    assert_same source, session.interact(input: source, escape: "\x1d", output: StringIO.new, timeout: 2)
-    assert session.alive?
-    session.write("printf 'AFTER_LOCAL_EOF\\n'\n")
-    assert_equal 1, session.expect(/AFTER_LOCAL_EOF\r?\n/, timeout: 2)
-  end
-
-  def test_remote_callback_exception_restores_both_terminals
-    session = shell_session
-    _, slave, source = local_terminal
-    local_mode = InteractProbe.configuration(source)
-    remote_mode = InteractProbe.configuration(session)
-    old_settings = InteractProbe.settings(session)
-    session.on_sequence("CALLBACK_FAILURE") { raise "test callback failed" }
-    session.write("printf 'CALLBACK_FAILURE\\n'\n")
-    error = assert_raises(RuntimeError) { session.interact(input: source, escape: "\x1d", output: slave, timeout: 2) }
-    assert_equal "test callback failed", error.message
-    assert_equal local_mode, InteractProbe.configuration(source)
-    assert_equal remote_mode, InteractProbe.configuration(session)
-    assert_equal old_settings[0..3], InteractProbe.settings(session)[0..3]
-    assert session.alive?
-  end
-
-  def test_output_io_failure_restores_input_terminal
-    session = shell_session
-    _, slave, source = local_terminal
-    saved = InteractProbe.configuration(source)
-    output = StringIO.new
-    output.close
-    session.write("printf 'OUTPUT_FAILURE\\n'\n")
-    assert_raises(IOError) { session.interact(input: source, escape: "\x1d", output: output, timeout: 2) }
-    assert_equal saved, InteractProbe.configuration(source)
-    refute slave.closed?
-  end
-end