expect-pty 0.5.3 → 0.6.1

data/test/terminal_cleanup_test.rb

@@ -1,349 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class TerminalCleanupTest < ExpectTest
-  def test_read_failures_preserve_identity_reap_helper_and_leave_main_session_usable
-    [IOError.new("read failed"), Interrupt.new("interrupted"), SystemExit.new(17)].each do |failure|
-      session = terminal_session
-      main_pid = session.pid
-      with_stty_pipe do |reader, sink, spawned|
-        reader.stub(:read, -> { raise failure }) do
-          assert_same failure, assert_raises(failure.class) { bounded { session.stty } }
-        end
-        assert reader.closed?
-        assert sink.closed?
-        assert_reaped spawned.fetch(:pid)
-      end
-      assert_main_session_usable session, main_pid
-    end
-  end
-
-  def test_read_error_wins_over_close_error_and_helper_is_still_reaped
-    session = terminal_session
-    failure = IOError.new("read failed")
-    attempts = 0
-    with_stty_pipe do |reader, sink, spawned|
-      reader.stub(:read, -> { raise failure }) do
-        reader.stub(:close, lambda {
-          attempts += 1
-          raise IOError, "close failed"
-        }) do
-          assert_same failure, assert_raises(IOError) { bounded { session.stty } }
-          refute reader.closed?, "permanently failing close must not be reported as closed"
-          assert sink.closed?
-          assert_reaped spawned.fetch(:pid)
-        end
-      end
-    end
-    assert_equal 1, attempts
-  end
-
-  def test_cleanup_error_after_success_is_visible_even_inside_caller_rescue
-    session = terminal_session
-    failure = IOError.new("close failed")
-    begin
-      raise ArgumentError, "already handled"
-    rescue ArgumentError
-      with_stty_pipe do |reader, sink, spawned|
-        reader.stub(:close, -> { raise failure }) do
-          assert_same failure, assert_raises(IOError) { bounded { session.stty } }
-          assert sink.closed?
-          assert_reaped spawned.fetch(:pid)
-        end
-      end
-    end
-  end
-
-  def test_spawn_failure_attempts_both_closes_and_keeps_missing_command_cause
-    session = terminal_session
-    reader, sink = IO.pipe
-    @ios.push(reader, sink)
-    failure = Errno::ENOENT.new("missing stty")
-    IO.stub(:pipe, [reader, sink]) do
-      Process.stub(:spawn, ->(*) { raise failure }) do
-        Process.stub(:kill, ->(*) { flunk "no helper was spawned" }) do
-          reader.stub(:close, -> { raise IOError, "reader close failed" }) do
-            error = assert_raises(IOError) { session.stty }
-            assert_match "stty executable not found", error.message
-            assert_same failure, error.cause
-            assert sink.closed?
-          end
-        end
-      end
-    end
-  end
-
-  def test_externally_reaped_helper_is_not_signalled_and_does_not_change_main_status
-    session = terminal_session
-    main_pid = session.pid
-    failure = IOError.new("read failed after external wait")
-    with_stty_pipe do |reader, _sink, spawned|
-      reader.stub(:read, lambda {
-        bounded { Process.waitpid2(spawned.fetch(:pid)) }
-        raise failure
-      }) do
-        Process.stub(:kill, ->(*) { flunk "must not signal an externally reaped PID" }) do
-          assert_same failure, assert_raises(IOError) { bounded { session.stty } }
-        end
-      end
-      assert_reaped spawned.fetch(:pid)
-    end
-    assert_main_session_usable session, main_pid
-  end
-
-  def test_uncooperative_helper_is_killed_and_reaped_after_read_failure
-    session = terminal_session
-    failure = IOError.new("read failed")
-    command = [RbConfig.ruby, "--disable-gems", "-e",
-               'Signal.trap("TERM", "IGNORE"); STDOUT.sync = true; puts "ready"; sleep 60']
-    signals = []
-    kill = Process.method(:kill)
-    with_stty_pipe(command: command) do |reader, _sink, spawned|
-      read = reader.method(:gets)
-      reader.stub(:read, lambda {
-        assert_equal("ready\n", bounded { read.call })
-        raise failure
-      }) do
-        Process.stub(:kill, lambda { |signal, pid|
-          signals << [signal, pid]
-          kill.call(signal, pid)
-        }) do
-          assert_same failure, assert_raises(IOError) { bounded(2) { session.stty } }
-        end
-      end
-      assert_equal [["TERM", spawned.fetch(:pid)], ["KILL", spawned.fetch(:pid)]], signals
-      assert_reaped spawned.fetch(:pid)
-    end
-  end
-
-  def test_normal_wait_retries_eintr_without_signalling_or_sleeping
-    session = terminal_session
-    wait = Process.method(:waitpid2)
-    attempts = 0
-    with_stty_pipe do |_reader, _sink, spawned|
-      Process.stub(:waitpid2, lambda { |pid, *flags|
-        assert_equal spawned.fetch(:pid), pid
-        attempts += 1
-        raise Errno::EINTR if attempts == 1
-
-        wait.call(pid, *flags)
-      }) do
-        session.stub(:sleep, ->(*) { flunk "successful stty must not add a fixed delay" }) do
-          Process.stub(:kill, ->(*) { flunk "successful helper must not be signalled" }) do
-            refute_empty session.stty
-          end
-        end
-      end
-      assert_equal 2, attempts
-      assert_reaped spawned.fetch(:pid)
-    end
-  end
-
-  def test_continuous_cleanup_eintr_has_a_fixed_budget_and_detaches_real_helper
-    session = terminal_session
-    failure = IOError.new("read failed")
-    clock = 0.0
-    waiter = nil
-    detach = Process.method(:detach)
-    attempts = 0
-    with_stty_pipe do |reader, _sink, spawned|
-      reader.stub(:read, -> { raise failure }) do
-        Expect.stub(:monotonic, -> { clock }) do
-          session.stub(:sleep, ->(duration) { clock += duration }) do
-            Process.stub(:waitpid2, lambda { |pid, flags|
-              assert_equal spawned.fetch(:pid), pid
-              assert_equal Process::WNOHANG, flags
-              attempts += 1
-              raise Errno::EINTR
-            }) do
-              Process.stub(:kill, ->(*) { flunk "ownership has not been checked successfully" }) do
-                Process.stub(:detach, lambda { |pid|
-                  assert_equal spawned.fetch(:pid), pid
-                  waiter = detach.call(pid)
-                }) do
-                  assert_same failure, assert_raises(IOError) { bounded { session.stty } }
-                end
-              end
-            end
-          end
-        end
-      end
-      assert_operator attempts, :>, 3
-      assert_in_delta 0.15, clock, 0.000001
-      refute_nil waiter
-      assert_instance_of(Process::Status, bounded { waiter.value })
-      assert_reaped spawned.fetch(:pid)
-    end
-  end
-
-  def test_esrch_between_poll_and_signal_still_reaps_without_fabricating_status
-    session = terminal_session
-    main_pid = session.pid
-    failure = IOError.new("read failed")
-    clock = 0.0
-    signalled = false
-    wait = Process.method(:waitpid2)
-    with_stty_pipe do |reader, _sink, spawned|
-      reader.stub(:read, -> { raise failure }) do
-        Expect.stub(:monotonic, -> { clock }) do
-          session.stub(:sleep, ->(duration) { clock += duration }) do
-            Process.stub(:waitpid2, lambda { |pid, flags|
-              assert_equal Process::WNOHANG, flags
-              signalled ? wait.call(pid, flags) : nil
-            }) do
-              Process.stub(:kill, lambda { |signal, pid|
-                assert_equal "TERM", signal
-                assert_equal spawned.fetch(:pid), pid
-                bounded { wait.call(pid) }
-                signalled = true
-                raise Errno::ESRCH
-              }) do
-                Process.stub(:detach, ->(*) { flunk "ECHILD already released ownership" }) do
-                  assert_same failure, assert_raises(IOError) { bounded { session.stty } }
-                end
-              end
-            end
-          end
-        end
-      end
-      assert signalled
-      assert_reaped spawned.fetch(:pid)
-    end
-    assert_main_session_usable session, main_pid
-  end
-
-  def test_sink_close_failure_still_attempts_reader_close_and_reaps_helper
-    session = terminal_session
-    failure = IOError.new("sink close failed")
-    attempts = 0
-    with_stty_pipe do |reader, sink, spawned|
-      sink.stub(:close, lambda {
-        attempts += 1
-        raise failure
-      }) do
-        assert_same failure, assert_raises(IOError) { bounded { session.stty } }
-        assert reader.closed?
-        refute sink.closed?
-        assert_reaped spawned.fetch(:pid)
-      end
-    end
-    assert_equal 2, attempts
-  end
-
-  def test_forked_copy_closes_local_pipes_without_reaping_or_signalling_parent_helper
-    session = terminal_session
-    current_pid = Process.pid
-    failure = IOError.new("unwind in forked copy")
-    with_stty_pipe do |reader, sink, _spawned|
-      Process.stub(:pid, -> { current_pid }) do
-        reader.stub(:read, lambda {
-          current_pid = -1 # 在资源登记后模拟 fork 子进程的身份，父进程仍拥有辅助 PID。
-          raise failure
-        }) do
-          Process.stub(:waitpid2, ->(*) { flunk "non-owner must not wait for the parent's helper" }) do
-            Process.stub(:kill, ->(*) { flunk "non-owner must not signal the parent's helper" }) do
-              Process.stub(:detach, ->(*) { flunk "non-owner must not detach the parent's helper" }) do
-                assert_same failure, assert_raises(IOError) { session.stty }
-                assert reader.closed?
-                assert sink.closed?
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  def test_ledger_initialization_failure_still_closes_both_pipes
-    session = terminal_session
-    [IOError.new("ledger failed"), Interrupt.new("interrupted registration")].each do |failure|
-      with_stty_pipe do |reader, sink, spawned|
-        Expect::SessionResources.stub(:new, ->(*) { raise failure }) do
-          assert_same failure, assert_raises(failure.class) { session.stty }
-          assert reader.closed?
-          assert sink.closed?
-          assert_empty spawned
-        end
-      end
-    end
-  end
-
-  def test_fork_during_cleanup_wait_stops_process_cleanup
-    session = terminal_session
-    current_pid = Process.pid
-    failure = IOError.new("read failed")
-    with_stty_pipe do |reader, sink, _spawned|
-      Process.stub(:pid, -> { current_pid }) do
-        reader.stub(:read, -> { raise failure }) do
-          session.stub(:sleep, ->(*) { current_pid = -1 }) do
-            Process.stub(:waitpid2, ->(*) {}) do
-              Process.stub(:kill, ->(*) { flunk "fork during wait must release inherited process ownership" }) do
-                Process.stub(:detach, ->(*) { flunk "non-owner must not detach" }) do
-                  assert_same failure, assert_raises(IOError) { bounded { session.stty } }
-                  assert reader.closed?
-                  assert sink.closed?
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  private
-
-  def terminal_session
-    session = child(<<~'RUBY', raw_pty: true)
-      puts "ready"
-      while (line = STDIN.gets)
-        puts "reply:#{line.strip}"
-      end
-    RUBY
-    assert_equal 1, session.expect("ready", timeout: 2)
-    session
-  end
-
-  def assert_main_session_usable(session, main_pid)
-    assert_equal main_pid, session.pid
-    assert_nil session.process_status
-    refute session.closed?
-    session.puts "still usable"
-    assert_equal 1, session.expect("reply:still usable", timeout: 2)
-  end
-
-  def assert_reaped(pid)
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-  end
-
-  # 只替换本次 stty 的管道；即使断言失败，恢复全局 stub 后仍由探针回收自己的真实子进程。
-  def with_stty_pipe(command: nil)
-    reader, sink = IO.pipe
-    @ios.push(reader, sink)
-    spawned = {}
-    spawn = Process.method(:spawn)
-    IO.stub(:pipe, [reader, sink]) do
-      Process.stub(:spawn, lambda { |*arguments, **options|
-        spawned[:pid] = spawn.call(*(command || arguments), **options)
-      }) do
-        yield reader, sink, spawned
-      end
-    end
-  ensure
-    reap_probe_child(spawned[:pid]) if spawned && spawned[:pid]
-  end
-
-  def reap_probe_child(pid)
-    return if Process.waitpid(pid, Process::WNOHANG)
-
-    begin
-      Process.kill("KILL", pid)
-    rescue Errno::ESRCH
-      nil
-    end
-    bounded { Process.waitpid(pid) }
-  rescue Errno::ECHILD
-    nil
-  end
-end

data/test/test_helper.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "minitest/autorun"
-require "timeout"
-require "stringio"
-require "tempfile"
-require "tmpdir"
-require "socket"
-require_relative "../lib/expect"
-
-class ExpectTest < Minitest::Test
-  def setup
-    @sessions = []
-    @ios = []
-    @threads = []
-    @configuration = Expect.configuration
-  end
-
-  def teardown
-    @threads.each { |thread| thread.kill.join if thread.alive? }
-    @sessions.reverse_each { |session| session.hard_close(timeout: 0.03) }
-    @ios.each { |io| io.close unless io.closed? }
-    Expect.configure(**@configuration.to_h)
-  end
-
-  def child(script, **)
-    session = Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", "STDOUT.sync = true; STDERR.sync = true; #{script}",
-                           log_stdout: false, **)
-    @sessions << session
-    session
-  end
-
-  def pipe_session(**)
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    session = Expect.open(reader, **)
-    @sessions << session
-    [session, writer]
-  end
-
-  def background(&)
-    @threads << Thread.new(&)
-    @threads.last
-  end
-
-  def bounded(seconds = 5, &)
-    Timeout.timeout(seconds, &)
-  end
-
-  def terminal_configuration(session)
-    state = session.stty
-    return state unless RUBY_PLATFORM.include?("darwin")
-
-    # Darwin marks pending-input retyping after tcsetattr. PENDIN is a kernel
-    # state bit (sys/termios.h), not a changed terminal configuration.
-    state.sub(/lflag=([0-9a-f]+)/) { "lflag=#{(Regexp.last_match(1).to_i(16) & ~0x20000000).to_s(16)}" }
-  end
-end

data/test/timeout_test.rb

@@ -1,289 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class TimeoutTest < ExpectTest
-  def test_default_timeout_and_explicit_infinite_timeout
-    session, writer = pipe_session
-    session.timeout = 0.01
-    assert_nil session.expect("ready")
-    background do
-      sleep 0.04
-      writer.write("ready")
-    end
-    assert_equal(1, bounded { session.expect("ready", timeout: nil) })
-  end
-
-  def test_zero_timeout_polls_existing_data_without_waiting
-    session, writer = pipe_session
-    writer.write("ready")
-    assert_equal 1, session.expect("ready", timeout: 0)
-    start = Expect.monotonic
-    assert_nil session.expect("missing", timeout: 0)
-    assert_operator Expect.monotonic - start, :<, 0.1
-  end
-
-  def test_continue_resets_timeout
-    session, writer = pipe_session
-    number = with_timed_input(writer, [[7, "A"], [16, "B"]]) do
-      session.expect(timeout: 13) do
-        on("A") { Expect.continue }
-        on("B")
-      end
-    end
-    assert_equal 2, number
-  end
-
-  def test_continue_timeout_preserves_deadline
-    session, writer = pipe_session
-    number = with_timed_input(writer, [[7, "A"], [19, "B"]]) do
-      result = session.expect(timeout: 14) do
-        on("A") { Expect.continue(reset_timeout: false) }
-        on("B")
-      end
-      assert_equal 14, Expect.monotonic
-      result
-    end
-    assert_nil number
-    assert_equal :timeout, session.error
-  end
-
-  def test_eof_continuation_without_reset_observes_the_deadline_before_matching_again
-    first, = pipe_session
-    second, = pipe_session
-    first.close
-    now = 0.0
-    result = Expect.stub(:monotonic, -> { now }) do
-      Expect.expect_result(timeout: 1) do
-        eof(from: first) do
-          now = 2.0
-          second.buffer = "ready"
-          Expect.continue(reset_timeout: false)
-        end
-        on("ready", from: second)
-      end
-    end
-
-    assert result.timeout?
-    assert_same second, result.session
-    assert_equal "ready", second.buffer
-    assert first.last_result.eof?
-  end
-
-  def test_eof_continuation_can_reset_an_expired_deadline
-    first, = pipe_session
-    second, = pipe_session
-    first.close
-    now = 0.0
-    result = Expect.stub(:monotonic, -> { now }) do
-      Expect.expect_result(timeout: 1) do
-        eof(from: first) do
-          now = 2.0
-          second.buffer = "ready"
-          Expect.continue
-        end
-        on("ready", from: second)
-      end
-    end
-
-    assert_equal "ready", result.match
-    assert_same second, result.session
-  end
-
-  def test_last_eof_returns_even_when_continuation_deadline_has_expired
-    session, = pipe_session
-    session.close
-    now = 0.0
-    result = Expect.stub(:monotonic, -> { now }) do
-      session.expect_result(timeout: 1) do
-        eof do
-          now = 2.0
-          Expect.continue(reset_timeout: false)
-        end
-      end
-    end
-
-    assert result.eof?
-    assert_same session, result.session
-  end
-
-  def test_expired_eof_continuation_delivers_all_known_eof_events
-    sessions = Array.new(3) { pipe_session.first }
-    sessions.each(&:close)
-    seen = []
-    result = Expect.expect_result(from: sessions, timeout: 0) do
-      eof do |session|
-        seen << session
-        Expect.continue(reset_timeout: false)
-      end
-    end
-
-    assert result.eof?
-    assert_equal sessions, seen
-    assert(sessions.all? { |session| session.last_result.eof? })
-  end
-
-  def test_expired_eof_continuation_handles_known_eof_before_timing_out_live_sources
-    first, = pipe_session
-    second, = pipe_session
-    live, = pipe_session
-    [first, second].each(&:close)
-    seen = []
-    timed_out = nil
-    result = Expect.expect_result(timeout: 0) do
-      eof(from: [first, second]) do |session|
-        seen << session
-        live.buffer = "ready"
-        Expect.continue(reset_timeout: false)
-      end
-      on("ready", from: live)
-      timeout { |sessions| timed_out = sessions }
-    end
-
-    assert result.timeout?
-    assert_equal [first, second], seen
-    assert_equal [live], timed_out
-    assert_equal "ready", live.buffer
-  end
-
-  def test_reset_after_expired_eof_continuation_resumes_text_matching
-    %i[eof timeout].each do |reset_event|
-      first, = pipe_session
-      second, = pipe_session
-      live, = pipe_session
-      [first, second].each(&:close)
-      result = Expect.expect_result(timeout: 0) do
-        eof(from: first) do
-          live.buffer = "ready"
-          Expect.continue(reset_timeout: false)
-        end
-        eof(from: second) { Expect.continue(reset_timeout: reset_event == :eof) }
-        on("ready", from: live)
-        timeout { Expect.continue }
-      end
-
-      assert_equal "ready", result.match
-      assert_same live, result.session
-    end
-  end
-
-  def test_restart_timeout_on_receive
-    session, writer = pipe_session
-    session.reset_timeout_on_read = true
-    number = with_timed_input(writer, [[6, "."], [12, "."], [18, "."], [24, ".done"]]) do
-      session.expect("done", timeout: 10)
-    end
-    assert_equal 1, number
-  end
-
-  def test_receive_keeps_deadline_without_reset
-    session, writer = pipe_session
-    result = with_timed_input(writer, [[6, "."], [12, "done"]]) do
-      session.expect_result("done", timeout: 10)
-    end
-    assert result.timeout?
-    assert_equal ".", session.buffer
-  end
-
-  def test_timeout_callback_receives_group_and_can_retry
-    session, = pipe_session
-    count = 0
-    groups = []
-    argument = :value
-    number = session.expect(timeout: 0.01) do
-      timeout do |objects|
-        groups << [objects, argument]
-        count += 1
-        count < 3 ? Expect.continue : nil
-      end
-    end
-    assert_nil number
-    assert_equal 3, count
-    assert_equal [[[session], :value]] * 3, groups
-  end
-
-  def test_callback_exception_propagates
-    session, = pipe_session
-    session.buffer = "ready"
-    assert_raises(RuntimeError) do
-      session.expect(timeout: 0) { on("ready") { raise "handler failed" } }
-    end
-    assert_equal "ready", session.match
-  end
-
-  def test_continuation_through_buffered_states
-    session, = pipe_session
-    session.buffer = "A B C D End"
-    states = []
-    number = session.expect(timeout: 1) do
-      on(/[ABCD]/) do |connection|
-        states << connection.match
-        connection.continue
-      end
-      on("End")
-    end
-    assert_equal 2, number
-    assert_equal %w[A B C D], states
-  end
-
-  def test_absolute_timeout_even_with_continuous_unmatched_output
-    session = child('loop { print "x" * 16384 }', raw_pty: true, buffer_limit: 1024)
-    start = Expect.monotonic
-    result = bounded(2) { session.expect_result("missing", timeout: 0.05) }
-    assert result.timeout?
-    assert_operator Expect.monotonic - start, :<, 0.4
-  end
-
-  def test_repeated_select_interruptions_do_not_extend_the_deadline
-    session, = pipe_session
-    interrupted = lambda do |*|
-      sleep 0.01
-      raise Errno::EINTR
-    end
-    result = bounded(1) do
-      IO.stub(:select, interrupted) { session.expect_result("missing", timeout: 0.02) }
-    end
-    assert result.timeout?
-  end
-
-  def test_interrupted_read_retries_without_losing_input
-    session, writer = pipe_session
-    writer.write("ready")
-    original = session.to_io.method(:read_nonblock)
-    interrupted = true
-    read = lambda do |*args, **options|
-      if interrupted
-        interrupted = false
-        raise Errno::EINTR
-      end
-      original.call(*args, **options)
-    end
-    session.to_io.stub(:read_nonblock, read) do
-      assert_equal 1, session.expect("ready", timeout: 1)
-    end
-    assert_equal "ready", session.match
-  end
-
-  private
-
-  # 按虚拟时间向真实管道写入数据；select 仍按调用方给定的期限决定就绪或超时。
-  # 这样可精确检查期限是否重置，不依赖 CI 线程能否在几十毫秒内获得调度。
-  def with_timed_input(writer, events, &block)
-    now = 0.0
-    pending = events.dup
-    select = lambda do |readers, _writers, _errors, timeout|
-      deadline = now + timeout
-      if pending.any? && pending.first[0] <= deadline
-        now, data = pending.shift
-        writer.write(data)
-        [readers, [], []]
-      else
-        now = deadline
-        nil
-      end
-    end
-    Expect.stub(:monotonic, -> { now }) do
-      IO.stub(:select, select, &block)
-    end
-  end
-end