expect-pty 0.5.3 → 0.6.1

data/test/process_interruption_test.rb

@@ -1,296 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-require "minitest/mock"
-
-class ProcessInterruptionTest < ExpectTest
-  def test_hard_close_reaps_a_real_child_after_one_wait_interruption
-    session = child('Signal.trap("HUP", "IGNORE"); Signal.trap("TERM", "IGNORE"); puts "ready"; sleep 60',
-                    raw_pty: true)
-    assert_equal 1, session.expect("ready", timeout: 2)
-    pid = session.pid
-    original = Process.method(:waitpid2)
-    interrupted = false
-    Process.stub(:waitpid2, lambda { |*args|
-      if args.first == pid && !interrupted
-        interrupted = true
-        raise Errno::EINTR
-      end
-      original.call(*args)
-    }) do
-      status = bounded { session.hard_close(timeout: 0) }
-      assert_instance_of Process::Status, status
-      assert_equal Signal.list.fetch("KILL"), status.termsig
-      assert_same status, session.process_status
-    end
-    assert interrupted
-    assert_nil session.pid
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-  ensure
-    session&.hard_close(timeout: 0)
-  end
-
-  def test_continuous_wait_interruptions_keep_the_original_deadline_and_pid
-    with_fake_child do |session, resources, calls|
-      with_clock(session) do |now|
-        Process.stub(:waitpid2, lambda { |*|
-          calls << :wait
-          raise Errno::EINTR
-        }) do
-          assert_nil(bounded { session.wait(timeout: 0.03) })
-          assert_equal 0.03, now.call
-          assert_operator calls.size, :<=, 5
-          assert_operator calls.size, :>=, 3
-          assert_equal 123_456, resources.pid
-          assert_nil resources.status
-        end
-      end
-    end
-  end
-
-  def test_continuous_wait_and_signal_interruptions_are_bounded_during_hard_close
-    with_fake_child do |session, resources, calls|
-      with_clock(session) do |now|
-        Process.stub(:waitpid2, lambda { |*|
-          calls << :wait
-          raise Errno::EINTR
-        }) do
-          Process.stub(:kill, lambda { |signal, *|
-            calls << signal
-            raise Errno::EINTR
-          }) do
-            assert_nil(bounded { session.hard_close(timeout: 0.02) })
-            assert_in_delta 1.04, now.call, 0.000001
-            assert_operator calls.count("TERM"), :>, 1
-            assert_operator calls.count("KILL"), :>, 1
-            assert_operator calls.size, :<, 230
-            assert_equal 123_456, resources.pid
-            assert_nil resources.status
-          end
-        end
-      end
-    end
-  end
-
-  def test_signal_interruption_retries_without_extending_the_soft_close_budget
-    with_fake_child do |session, resources, calls|
-      with_clock(session) do |now|
-        Process.stub(:kill, lambda { |signal, _pid|
-          calls << signal
-          raise Errno::EINTR if calls.count(signal) == 1
-        }) do
-          assert_nil session.soft_close(timeout: 0, term_timeout: 0.03)
-          assert_equal 0.03, now.call
-          assert_equal %w[TERM TERM], calls.grep(String)
-          assert_equal 123_456, resources.pid
-          assert_nil resources.status
-        end
-      end
-    end
-  end
-
-  def test_echild_clears_ownership_before_any_signal_or_detach
-    with_fake_child do |session, resources, calls|
-      Process.stub(:waitpid2, ->(*) { raise Errno::ECHILD }) do
-        assert_nil session.hard_close(timeout: 0)
-        resources.finalize
-        assert_nil resources.pid
-        assert_nil resources.status
-        assert_empty calls
-      end
-    end
-  end
-
-  def test_finalizer_continues_to_kill_and_detach_after_interrupted_reap
-    with_fake_child do |_session, resources, calls|
-      Process.stub(:waitpid2, lambda { |*|
-        calls << :wait
-        raise Errno::EINTR
-      }) do
-        bounded { resources.finalize }
-      end
-      assert_equal [:wait, "KILL", :detach], calls
-      assert_nil resources.pid
-      assert_nil resources.status
-    end
-  end
-
-  def test_finalizer_detaches_even_if_kill_is_continuously_interrupted
-    with_fake_child do |session, resources, calls|
-      session.log_to { flunk "finalizer invoked a user callback" }
-      Process.stub(:kill, lambda { |signal, *|
-        calls << signal
-        raise Errno::EINTR
-      }) do
-        bounded { resources.finalize }
-      end
-      assert_equal :detach, calls.last
-      assert_operator calls.count("KILL"), :>=, 1
-      assert_operator calls.count("KILL"), :<=, 2
-      assert_nil resources.pid
-      assert_nil resources.status
-    end
-  end
-
-  def test_finalizer_retains_unknown_pid_if_detach_also_fails
-    with_fake_child do |_session, resources, _calls|
-      Process.stub(:detach, ->(*) { raise Errno::EINTR }) { bounded { resources.finalize } }
-      assert_equal 123_456, resources.pid
-      assert_nil resources.status
-    end
-  end
-
-  def test_non_owner_never_waits_signals_or_detaches
-    with_fake_child do |session, resources, calls|
-      Process.stub(:pid, resources.owner + 1) do
-        resources.finalize
-        assert_nil session.wait(timeout: 0)
-        assert_nil session.hard_close(timeout: 0)
-      end
-      assert_empty calls
-      assert_equal 123_456, resources.pid
-    end
-  end
-
-  def test_forked_copy_cannot_reap_signal_or_detach_the_parent_child
-    session = child('puts "ready"; sleep 60', raw_pty: true)
-    assert_equal 1, session.expect("ready", timeout: 2)
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    probe = fork do
-      reader.close
-      forbidden = ->(*) { raise "non-owner attempted process cleanup" }
-      Process.stub(:waitpid2, forbidden) do
-        Process.stub(:kill, forbidden) do
-          Process.stub(:detach, forbidden) do
-            session.instance_variable_get(:@resources).finalize
-            session.hard_close(timeout: 0)
-            writer.write("ok")
-          end
-        end
-      end
-      exit! 0
-    rescue Exception # rubocop:disable Lint/RescueException -- 子进程只回传验证失败，父进程负责回收。
-      exit! 1
-    end
-    writer.close
-    assert_equal("ok", bounded { reader.read })
-    status = bounded { Process.waitpid2(probe).last }
-    probe = nil
-    assert status.success?
-    assert session.alive?
-  ensure
-    if probe
-      begin
-        Process.kill("KILL", probe)
-      rescue Errno::ESRCH
-        nil
-      end
-      begin
-        Process.waitpid(probe)
-      rescue Errno::ECHILD
-        nil
-      end
-    end
-    session&.hard_close(timeout: 0)
-  end
-
-  def test_finalizer_rechecks_ownership_before_detaching_after_a_signal
-    with_fake_child do |_session, resources, calls|
-      owner = resources.owner
-      Process.stub(:pid, -> { owner }) do
-        Process.stub(:kill, lambda { |signal, *|
-          calls << signal
-          owner += 1
-        }) do
-          resources.finalize
-        end
-      end
-      assert_equal [:wait, "KILL"], calls
-      assert_equal 123_456, resources.pid
-      assert_nil resources.status
-    end
-  end
-
-  def test_esrch_during_signal_still_reaps_without_inventing_status
-    with_fake_child do |session, resources, calls|
-      gone = false
-      Process.stub(:waitpid2, lambda { |*|
-        calls << :wait
-        raise Errno::ECHILD if gone
-      }) do
-        Process.stub(:kill, lambda { |signal, *|
-          calls << signal
-          gone = true
-          raise Errno::ESRCH
-        }) do
-          assert_nil session.hard_close(timeout: 0)
-        end
-      end
-      assert_equal [:wait, :wait, "TERM", :wait], calls
-      assert_nil resources.pid
-      assert_nil resources.status
-    end
-  end
-
-  def test_zero_budget_close_returns_status_reaped_after_esrch
-    status = child("exit 7").wait(timeout: 2)
-    assert_instance_of Process::Status, status
-    %i[soft_close hard_close].each do |method|
-      with_fake_child do |session, resources, calls|
-        gone = false
-        Process.stub(:waitpid2, lambda { |pid, *|
-          calls << :wait
-          [pid, status] if gone
-        }) do
-          Process.stub(:kill, lambda { |signal, *|
-            calls << signal
-            gone = true
-            raise Errno::ESRCH
-          }) do
-            options = { timeout: 0 }
-            options[:term_timeout] = 0 if method == :soft_close
-            assert_same status, session.public_send(method, **options)
-          end
-        end
-        assert_nil resources.pid
-        assert_same status, session.process_status
-        assert_equal [:wait, :wait, "TERM", :wait], calls
-      end
-    end
-  end
-
-  private
-
-  # 假 PID 只存在于系统调用全部被替换的作用域；ensure 先撤销 PID，再交给通用 teardown。
-  def with_fake_child
-    session, = pipe_session
-    resources = session.instance_variable_get(:@resources)
-    calls = []
-    originals = %i[waitpid2 kill detach].to_h { |name| [name, Process.method(name)] }
-    Process.define_singleton_method(:waitpid2) do |*|
-      calls << :wait
-      nil
-    end
-    Process.define_singleton_method(:kill) do |signal, *|
-      calls << signal
-      1
-    end
-    Process.define_singleton_method(:detach) do |*|
-      calls << :detach
-      nil
-    end
-    resources.pid = 123_456
-    yield session, resources, calls
-  ensure
-    resources.pid = nil if resources
-    originals&.each { |name, method| Process.define_singleton_method(name, method) }
-  end
-
-  def with_clock(session)
-    now = 0.0
-    Expect.stub(:monotonic, -> { now }) do
-      session.stub(:sleep, ->(seconds) { now += seconds }) { yield -> { now } }
-    end
-  end
-end

data/test/process_test.rb

@@ -1,291 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class ProcessTest < ExpectTest
-  def test_spawn_has_controlling_terminal_and_merged_stderr
-    session = child(<<~RUBY)
-      terminal = File.open("/dev/tty", &:tty?)
-      puts [STDIN.tty?, STDOUT.tty?, STDERR.tty?, terminal].join(":")
-      STDERR.puts "error-stream"
-    RUBY
-    assert_equal 1, session.expect("true:true:true:true", timeout: 2)
-    assert_equal 1, session.expect("error-stream", timeout: 2)
-    session.soft_close(timeout: 1)
-    assert_equal 0, session.exit_code
-    assert_equal 0, session.process_status.to_i
-    assert session.closed?
-    refute session.alive?
-  end
-
-  def test_raw_mode_is_applied_before_child_starts
-    session = child(<<~'RUBY', raw_pty: true)
-      print "name: "
-      value = STDIN.gets
-      puts "reply=#{value.strip.reverse}"
-    RUBY
-    session.expect("name: ", timeout: 2)
-    session.write("crate\n")
-    assert_equal 1, session.expect("reply=etarc\n", timeout: 2)
-    assert_equal "", session.before
-  end
-
-  def test_new_pty_supports_slave_configuration_before_spawn
-    session = Expect.new(log_stdout: false)
-    @sessions << session
-    assert session.slave.tty?
-    session.slave.echo = false
-    session.slave.winsize = [37, 111]
-    # 子进程需要 io-console gem，保留 RubyGems 以使用 Bundler 选定的版本。
-    session.spawn(RbConfig.ruby, "-rio/console", "-e",
-                  'STDOUT.sync = true; puts STDIN.winsize.join(":"); puts STDIN.gets')
-    assert_equal 1, session.expect("37:111", timeout: 2), session.before.inspect
-    assert_equal [37, 111], session.winsize
-    session.winsize = [24, 80]
-    assert_equal [24, 80], session.winsize
-    session.clear_buffer
-    session.write("line\n")
-    session.expect("line", timeout: 2)
-    session.expect(timeout: 2)
-    assert_equal "\r\n", session.before
-  end
-
-  def test_command_arguments_environment_and_directory
-    Dir.mktmpdir do |dir|
-      session = Expect.spawn(RbConfig.ruby, "--disable-gems", "-e",
-                             'puts ARGV.first; puts ENV.fetch("EXPECT_TEST_VALUE"); puts Dir.pwd', "a;$(exit) b",
-                             env: { "EXPECT_TEST_VALUE" => "environment" }, chdir: dir,
-                             log_stdout: false, raw_pty: true)
-      @sessions << session
-      assert_equal 1, session.expect("a;$(exit) b\nenvironment\n#{File.realpath(dir)}\n", timeout: 2)
-    end
-  end
-
-  def test_string_command_supports_shell_semantics
-    session = Expect.new("printf 'shell-one'; printf 'shell-two'", log_stdout: false)
-    @sessions << session
-    assert_equal 1, session.expect("shell-oneshell-two", timeout: 2)
-  end
-
-  def test_exec_failure_is_synchronous_and_reaped
-    session = Expect.new(log_stdout: false)
-    @sessions << session
-    error = assert_raises(Expect::SpawnError) { session.spawn("/no/such/expect-test-command") }
-    assert_match(/ENOENT/, error.message)
-    assert session.closed?
-    assert_nil session.pid
-    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
-      Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", "sleep 60", log_stdout: false) do |session|
-        pid = session.pid
-        raise "stop"
-      end
-    end
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-    assert_raises(Errno::ESRCH) { Process.kill(0, pid) }
-  end
-
-  def test_soft_close_drains_output_before_exit_and_returns_process_status
-    session = child('sleep 0.03; print "last output"; exit 7', raw_pty: true)
-    log = StringIO.new
-    session.log_to(log)
-    assert_equal 7, session.soft_close(timeout: 1).exitstatus
-    assert_equal "last output", log.string
-    assert_equal "last output", session.buffer
-    assert_equal 7, session.exit_code
-    refute log.closed?
-  end
-
-  def test_hard_close_escalates_uncooperative_child_and_reaps
-    session = child('Signal.trap("HUP", "IGNORE"); Signal.trap("TERM", "IGNORE"); puts "ready"; loop { sleep 1 }')
-    session.expect("ready", timeout: 2)
-    pid = session.pid
-    bounded(2) { session.hard_close(timeout: 0.03) }
-    assert_equal Signal.list.fetch("KILL"), session.process_status.termsig
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-    assert_equal session.process_status, session.hard_close
-  end
-
-  def test_soft_close_sends_term_and_returns_the_exit_status
-    session = child(<<~RUBY, raw_pty: true)
-      Signal.trap("HUP", "IGNORE")
-      Signal.trap("TERM") { exit 7 }
-      puts "ready"
-      sleep 60
-    RUBY
-    session.expect("ready", timeout: 2)
-    status = bounded { session.soft_close(timeout: 0, term_timeout: 1) }
-    assert_equal 7, status.exitstatus
-    assert session.closed?
-    refute session.alive?
-    assert_same status, session.soft_close(timeout: 0)
-  end
-
-  def test_soft_close_never_sends_kill_and_retains_a_live_pid_for_hard_close
-    session = child(<<~RUBY)
-      Signal.trap("HUP", "IGNORE")
-      Signal.trap("TERM", "IGNORE")
-      puts "ready"
-      sleep 60
-    RUBY
-    session.expect("ready", timeout: 2)
-    pid = session.pid
-    assert_nil(bounded { session.soft_close(timeout: 0, term_timeout: 0.03) })
-    assert session.closed?
-    assert session.alive?
-    assert_equal pid, session.pid
-    assert_nil session.wait(timeout: 0)
-    status = bounded { session.hard_close(timeout: 0.03) }
-    assert_equal Signal.list.fetch("KILL"), status.termsig
-    assert_nil session.pid
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-  end
-
-  def test_block_cleanup_uses_the_configured_graceful_close_and_drains_output
-    log = StringIO.new
-    connection = nil
-    value = Expect.spawn(RbConfig.ruby, "--disable-gems", "-e", 'sleep 0.03; puts "tail"',
-                         raw_pty: true, graceful_close: true) do |session|
-      connection = session
-      session.log_output = log
-      :finished
-    end
-    assert_equal :finished, value
-    assert_equal "tail\n", log.string
-    assert connection.closed?
-    assert_equal 0, connection.exit_code
-    refute log.closed?
-  end
-
-  def test_explicit_graceful_close_returns_nil_like_io_close
-    session = child('sleep 0.03; print "tail"', raw_pty: true)
-    assert_nil session.close(graceful: true)
-    assert_equal "tail", session.buffer
-    assert_equal 0, session.exit_code
-    assert_nil session.close
-  end
-
-  def test_close_still_reaps_the_child_when_graceful_logging_fails
-    session = child('puts "ready"; sleep 60', raw_pty: true)
-    pid = session.pid
-    session.log_to { raise IOError, "log failed" }
-    assert_raises(IOError) { bounded { session.close(graceful: true) } }
-    assert session.closed?
-    refute session.alive?
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-  end
-
-  def test_invalid_close_timeout_does_not_close_or_signal_the_child
-    session = child('puts "ready"; sleep 60')
-    session.expect("ready", timeout: 2)
-    assert_raises(ArgumentError) { session.soft_close(timeout: 0, term_timeout: nil) }
-    assert_raises(ArgumentError) { session.soft_close(timeout: 0, term_timeout: -1) }
-    assert_raises(ArgumentError) { session.hard_close(timeout: nil) }
-    refute session.closed?
-    assert session.alive?
-  end
-
-  def test_eof_does_not_prevent_buffered_match
-    session = child('print "final"; exit 4', raw_pty: true)
-    assert_equal 1, session.expect("final", timeout: 2)
-    assert session.expect_result(:eof, timeout: 2).eof?
-    assert_equal 4, session.wait(timeout: 1).exitstatus
-  end
-
-  def test_wait_timeout_and_explicit_close
-    session = child("sleep 0.15; exit 0")
-    assert_nil session.wait(timeout: 0)
-    assert session.alive?
-    assert_equal 0, session.wait(timeout: 1).exitstatus
-    refute session.alive?
-    session.close
-    assert_raises(IOError) { session.write("x") }
-  end
-
-  def test_borrowed_and_owned_io_lifetimes
-    session, writer = pipe_session
-    reader = session.to_io
-    session.close
-    refute reader.closed?
-    writer.write("x")
-    assert_equal "x", reader.read(1)
-    owned = Expect.open(reader, own: true)
-    owned.close
-    assert reader.closed?
-  end
-
-  def test_stty_roundtrip
-    session = child("sleep 30")
-    initial = session.stty
-    configuration = terminal_configuration(session)
-    session.stty("raw -echo")
-    refute session.to_io.echo?
-    session.stty(initial)
-    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
-    @sessions << session
-    refute session.log_stdout?
-    assert_equal 0.01, session.timeout
-    session.log_stdout = true
-    assert session.log_stdout
-    session.log_stdout = false
-    refute session.log_stdout
-    session.buffer_limit = 30
-    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