expect-pty 0.5.1 → 0.5.3

data/test/ownership_sequence_test.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "minitest/mock"
+
+class OwnershipSequenceTest < ExpectTest
+  SEEDS = [20_260_927, 1, 42].freeze
+
+  def test_failed_initialization_then_failed_cleanup_preserves_ownership_and_primary_error
+    SEEDS.each do |seed|
+      [true, false].each do |own|
+        reader, writer = IO.pipe
+        @ios.push(reader, writer)
+        attempts = []
+        failure = seed.odd? ? Interrupt.new : SystemExit.new(17)
+        original = writer.method(:close)
+        Expect::SessionResources.stub(:new, ->(*, **) { raise failure }) do
+          reader.stub(:close, lambda {
+            attempts << :reader
+            raise IOError, "injected close failure"
+          }) do
+            writer.stub(:close, lambda {
+              attempts << :writer
+              original.call
+            }) do
+              error = assert_raises(failure.class) { Expect.open(reader, writer: writer, own: own) }
+              assert_same failure, error, "seed=#{seed} own=#{own}"
+            end
+          end
+        end
+        assert_equal(own ? %i[reader writer] : [], attempts, "seed=#{seed} own=#{own}")
+        assert_equal own, writer.closed?
+        refute reader.closed?
+      end
+    end
+  end
+
+  def test_short_write_eintr_timeout_and_listener_replacement_keep_per_target_progress
+    SEEDS.each do |seed|
+      source, = pipe_session
+      sink, target_writer = IO.pipe
+      @ios.push(sink, target_writer)
+      target, = pipe_session(writer: target_writer, write_timeout: 0.01)
+      first = StringIO.new
+      replacement = StringIO.new
+      payload = Random.new(seed).bytes(9)
+      source.listeners = [first, target]
+      source.buffer = payload
+      accepted = 2
+      attempts = 0
+      now = 0.0
+      original = target_writer.method(:write_nonblock)
+      Expect.stub(:monotonic, -> { now }) do
+        target_writer.stub(:write_nonblock, lambda { |bytes, **options|
+          attempts += 1
+          case attempts
+          when 1 then original.call(bytes.byteslice(0, accepted), **options)
+          when 2 then raise Errno::EINTR
+          else
+            now = 0.02
+            :wait_writable
+          end
+        }) do
+          error = assert_raises(Expect::WriteTimeout) { bounded { Expect.interconnect(source, timeout: 1) } }
+          assert_equal accepted, error.bytes_written, "seed=#{seed} attempts=#{attempts}"
+        end
+      end
+      prefix = bounded { sink.read(accepted) }
+      assert_equal payload.byteslice(0, accepted), prefix, "seed=#{seed} confirmed=#{accepted}"
+      assert_equal payload, first.string.b, "seed=#{seed} first target"
+      assert_empty source.buffer
+      assert source.pending_output?
+      source.listeners = [replacement]
+      source.buffer = "new"
+      Expect.interconnect(source, timeout: 0)
+      suffix = bounded { sink.read(payload.bytesize - accepted) }
+      assert_equal payload, prefix + suffix, "seed=#{seed} resumed target"
+      assert_equal payload, first.string.b, "seed=#{seed} first target replay"
+      assert_equal "new", replacement.string, "seed=#{seed} replacement target"
+      refute source.pending_output?
+      assert_empty source.buffer
+    end
+  end
+
+  def test_escape_delivery_nested_match_and_resume_account_for_all_source_bytes_once
+    SEEDS.each do |seed|
+      source, producer = pipe_session
+      prefix = "prefix-#{seed}\0".b
+      payload = "#{prefix}!consumetail".b
+      log = StringIO.new
+      sink = StringIO.new
+      source.log_to(log)
+      source.listeners = [sink]
+      calls = 0
+      source.on_sequence("!") do
+        calls += 1
+        assert_equal prefix, sink.string.b, "seed=#{seed} prefix not delivered"
+        assert_equal "consume", source.expect_result("consume", timeout: 0).match
+        false
+      end
+      producer.write(payload)
+      assert_same(source, bounded { Expect.interconnect(source, timeout: 1) })
+      assert_equal "tail", source.buffer
+      assert_equal 1, calls
+      assert_equal payload.bytesize, prefix.bytesize + 1 + "consume".bytesize + source.buffer.bytesize
+      Expect.interconnect(source, timeout: 0)
+      assert_equal "#{prefix}tail", sink.string.b, "seed=#{seed} delivered bytes"
+      assert_equal payload, log.string.b, "seed=#{seed} received log replay"
+      assert_equal 1, calls
+      refute source.pending_output?
+      assert_empty source.buffer
+    end
+  end
+
+  def test_refused_recursion_then_sequential_relay_preserves_bytes_and_releases_ownership
+    SEEDS.each do |seed|
+      source, = pipe_session
+      payload = Random.new(seed).bytes(7)
+      sink = StringIO.new
+      original = sink.method(:write)
+      errors = []
+      sink.define_singleton_method(:write) do |bytes|
+        count = original.call(bytes)
+        begin
+          Expect.interconnect(source, timeout: 0)
+        rescue Expect::ReentrancyError => error
+          errors << error
+        end
+        count
+      end
+      source.listeners = [sink]
+      2.times do |index|
+        source.buffer = payload
+        Expect.interconnect(source, timeout: 0)
+        assert_equal payload * (index + 1), sink.string.b, "seed=#{seed} iteration=#{index}"
+        assert_equal index + 1, errors.size
+        assert_empty source.buffer
+        refute source.pending_output?
+      end
+    end
+  end
+
+  def test_eof_soft_close_hard_close_and_repeated_status_queries
+    reader, writer = IO.pipe
+    @ios.push(reader, writer)
+    session = Expect.open(reader, own: true)
+    @sessions << session
+    script = <<~RUBY
+      Signal.trap("HUP", "IGNORE")
+      Signal.trap("TERM", "IGNORE")
+      STDOUT.sync = true
+      print "tail"
+      STDOUT.reopen(File::NULL, "w")
+      sleep 60
+    RUBY
+    pid = Process.spawn(RbConfig.ruby, "--disable-gems", "-e", script, in: File::NULL, out: writer, err: File::NULL)
+    session.instance_variable_get(:@resources).pid = pid
+    writer.close
+    result = session.expect_result(:eof, timeout: 2)
+    assert result.eof?
+    assert_equal "tail", result.before
+    assert session.alive?
+    refute session.closed?
+    signals = []
+    original = Process.method(:kill)
+    Process.stub(:kill, lambda { |signal, child_pid|
+      signals << signal
+      original.call(signal, child_pid)
+    }) do
+      assert_nil session.soft_close(timeout: 0, term_timeout: 0)
+    end
+    assert_equal ["TERM"], signals
+    assert session.closed?
+    assert session.alive?
+    status = bounded { session.hard_close(timeout: 0) }
+    assert_equal Signal.list.fetch("KILL"), status.termsig
+    3.times { assert_same status, session.process_status }
+    assert_nil session.pid
+    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_expired_deadline_dispatches_known_eof_in_order_without_consuming_new_text
+    SEEDS.each do |seed|
+      ended = Array.new(2) { pipe_session.first }
+      ended.each(&:close)
+      ended.shuffle!(random: Random.new(seed))
+      live, producer = pipe_session
+      live.buffer = "buffered"
+      producer.write("unread")
+      seen = []
+      Expect.stub(:monotonic, 1.0) do
+        result = Expect.expect_result(from: [*ended, live], deadline: 1.0) do
+          on("buffered") { flunk "seed=#{seed} consumed text after deadline" }
+          eof do |session|
+            seen << session
+            Expect.continue(reset_timeout: seed.odd?)
+          end
+        end
+        assert result.timeout?
+      end
+      assert_equal ended, seen, "seed=#{seed} EOF order"
+      assert_equal "buffered", live.buffer
+      assert_equal "unread", live.to_io.read_nonblock(6)
+    end
+  end
+end

data/test/process_interruption_test.rb

@@ -0,0 +1,296 @@
+# 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/relay_reentrancy_test.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "minitest/mock"
+
+class RelayReentrancyTest < ExpectTest
+  def test_recursive_write_and_flush_cannot_duplicate_delivery_or_change_cursors
+    %i[write flush].each do |entry|
+      source, = pipe_session
+      output = StringIO.new
+      errors = []
+      snapshots = []
+      entered = false
+      original = output.method(entry)
+      output.define_singleton_method(entry) do |*arguments|
+        result = original.call(*arguments)
+        unless entered
+          entered = true
+          cursors = source.__send__(:relay_outputs)
+          snapshot = -> { [source.buffer, cursors.map { |c| c.instance_variable_get(:@offset) }] }
+          snapshots << snapshot.call
+          begin
+            Expect.interconnect(source, timeout: 0)
+          rescue StandardError => error
+            errors << error
+          end
+          snapshots << snapshot.call
+        end
+        result
+      end
+      source.listeners = [output]
+      source.buffer = "abc"
+      bounded { Expect.interconnect(source, timeout: 0) }
+      assert_equal "abc", output.string, "recursive #{entry} replayed bytes"
+      assert_equal(["Expect::ReentrancyError"], errors.map { |error| error.class.name })
+      assert_equal snapshots.first, snapshots.last
+      refute source.pending_output?
+    end
+  end
+
+  def test_escape_callback_cannot_enter_the_same_source_but_can_use_a_matcher
+    source, = pipe_session
+    output = StringIO.new
+    source.listeners = [output]
+    calls = 0
+    source.on_sequence("!") do
+      calls += 1
+      error = assert_raises(StandardError) { Expect.interconnect(source, timeout: 0) }
+      assert_equal "Expect::ReentrancyError", error.class.name
+      assert_equal "inside", source.expect_result("inside", timeout: 0).match
+      false
+    end
+    source.buffer = "prefix!insidetail"
+    assert_same source, Expect.interconnect(source, timeout: 1)
+    assert_equal 1, calls
+    assert_equal "prefix", output.string
+    assert_equal "tail", source.buffer
+    Expect.interconnect(source, timeout: 0)
+    assert_equal "prefixtail", output.string
+  end
+
+  def test_partial_overlap_does_not_steal_buffers_or_release_the_outer_owner
+    outer, = pipe_session
+    other, = pipe_session
+    other.buffer = "other"
+    output = StringIO.new
+    other.listeners = [output]
+    outer.on_sequence("!") do
+      2.times do
+        error = assert_raises(StandardError) { Expect.interconnect(other, outer, timeout: 0) }
+        assert_equal "Expect::ReentrancyError", error.class.name
+        assert_equal "other", other.buffer
+      end
+      Expect.interconnect(other, timeout: 0)
+      false
+    end
+    outer.buffer = "!tail"
+    assert_same outer, Expect.interconnect(outer, timeout: 1)
+    assert_equal "tail", outer.buffer
+    assert_equal "other", output.string
+  end
+
+  def test_disjoint_sources_and_duplicate_arguments_are_supported
+    outer, = pipe_session
+    inner, = pipe_session
+    sink = StringIO.new
+    inner.listeners = [sink]
+    inner.buffer = "independent"
+    outer.buffer = "!tail"
+    outer.on_sequence("!") do
+      Expect.interconnect(inner, inner, timeout: 0)
+      false
+    end
+    assert_same outer, Expect.interconnect(outer, outer, timeout: 1)
+    assert_equal "independent", sink.string
+    assert_equal "tail", outer.buffer
+  end
+
+  def test_uncaught_reentry_propagates_and_sequential_retry_releases_the_owner
+    source, = pipe_session
+    sink = StringIO.new
+    entered = false
+    original = sink.method(:write)
+    sink.define_singleton_method(:write) do |data|
+      unless entered
+        entered = true
+        Expect.interconnect(source, timeout: 0)
+      end
+      original.call(data)
+    end
+    source.listeners = [sink]
+    source.buffer = "once"
+    error = assert_raises(StandardError) { Expect.interconnect(source, timeout: 0) }
+    assert_equal "Expect::ReentrancyError", error.class.name
+    assert source.pending_output?
+    Expect.interconnect(source, timeout: 0)
+    assert_equal "once", sink.string
+    refute source.pending_output?
+  end
+
+  def test_preparation_failure_restores_all_moved_buffers_and_releases_ownership
+    first, = pipe_session
+    second, = pipe_session
+    first.buffer = "first"
+    second.buffer = "second"
+    error = IOError.new("injected preparation failure")
+    second.stub(:clear_buffer, -> { raise error }) do
+      assert_same error, assert_raises(IOError) { Expect.interconnect(first, second, timeout: 0) }
+    end
+    assert_equal "first", first.buffer
+    assert_equal "second", second.buffer
+    sink = StringIO.new
+    first.listeners = second.listeners = [sink]
+    Expect.interconnect(first, second, timeout: 0)
+    assert_equal "firstsecond", sink.string
+  end
+
+  def test_invalid_arguments_leave_buffers_unchanged
+    source, = pipe_session
+    source.buffer = "retained"
+    assert_raises(ArgumentError) { Expect.interconnect(source, timeout: -1) }
+    assert_raises(ArgumentError) { Expect.interconnect(source, Object.new, timeout: 0) }
+    assert_equal "retained", source.buffer
+    refute source.pending_output?
+  end
+
+  def test_eof_and_callback_errors_release_ownership
+    source, producer = pipe_session
+    failure = Interrupt.new("callback interrupted")
+    source.on_sequence("!") { raise failure }
+    source.buffer = "!tail"
+    assert_same failure, assert_raises(Interrupt) { Expect.interconnect(source, timeout: 1) }
+    producer.close
+    sink = StringIO.new
+    source.listeners = [sink]
+    2.times { assert_same source, Expect.interconnect(source, timeout: 1) }
+    assert_equal "tail", sink.string
+  end
+end