expect-pty 0.3.2 → 0.4.0

data/script/release.rb

@@ -83,11 +83,16 @@ class Release
 
   private
 
-  def capture(*arguments)
-    output, error, status = Open3.capture3(*arguments)
+  def capture(*)
+    capture_bytes(*).strip
+  end
+
+  # Git blob 是任意字节，不能沿用命令文本的 strip，尾部换行和 NUL 也属于发布内容。
+  def capture_bytes(*arguments)
+    output, error, status = Open3.capture3(*arguments, binmode: true)
     raise "#{arguments.first} failed: #{error.strip}" unless status.success?
 
-    output.strip
+    output
   end
 
   def command(*arguments)
@@ -124,7 +129,7 @@ class Release
   def verify_package
     package = Gem::Package.new(@artifact)
     expected = Gem::Specification.load(File.expand_path("expect-pty.gemspec"))
-    fields = %i[name version platform summary description authors licenses required_ruby_version
+    fields = %i[name version platform summary description authors licenses homepage required_ruby_version
                 required_rubygems_version require_paths metadata dependencies extensions executables bindir
                 post_install_message]
     unless fields.all? { |field| package.spec.public_send(field) == expected.public_send(field) }
@@ -132,6 +137,7 @@ class Release
     end
     raise "Artifact file list differs from the source" unless package.contents.sort == expected.files.sort
 
+    committed = committed_files if @commit
     # 直接检查归档中的权限，避免解包时本机 umask 改写执行位。
     File.open(@artifact, "rb") do |io|
       Gem::Package::TarReader.new(io) do |archive|
@@ -139,7 +145,10 @@ class Release
         package.open_tar_gz(data) do |tar|
           tar.each do |entry|
             file = entry.full_name
-            raise "Artifact differs from source: #{file}" unless entry.file? && entry.read == File.binread(file)
+            bytes = entry.read
+            raise "Artifact differs from source: #{file}" unless entry.file? && bytes == File.binread(file)
+
+            verify_committed_file(file, bytes, entry.header.mode, committed) if committed
             next if entry.header.mode & 0o111 == File.stat(file).mode & 0o111
 
             raise "Artifact executable permissions differ: #{file}"
@@ -149,6 +158,29 @@ class Release
     end
   end
 
+  # 工作区干净不代表所有打包文件都来自提交：ignore、assume-unchanged 和 filemode 均可隐藏差异。
+  # 只在正式发布时核对提交树；dry-run 仍允许检验尚未提交的开发源码。
+  def committed_files
+    capture_bytes("git", "ls-tree", "-rz", "--full-tree", @commit).split("\0").to_h do |record|
+      metadata, file = record.split("\t", 2)
+      mode, type, object = metadata.split
+      [file, [mode.to_i(8), type, object]]
+    end
+  end
+
+  def verify_committed_file(file, bytes, mode, committed)
+    committed_mode, type, object = committed[file.b]
+    unless type == "blob" && committed_mode & 0o170000 == 0o100000
+      raise "Artifact file is not in release commit: #{file}"
+    end
+    unless bytes == capture_bytes("git", "cat-file", "blob", object)
+      raise "Artifact differs from release commit: #{file}"
+    end
+    return if mode & 0o111 == committed_mode & 0o111
+
+    raise "Artifact executable permissions differ from release commit: #{file}"
+  end
+
   def get(path)
     uri = URI("#{GEM_HOST}#{path}")
     Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 30) do |http|

data/test/buffer_accounting_test.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class BufferAccountingTest < ExpectTest
+  def test_limit_discards_are_cumulative_and_distinct_from_consumption
+    session, = pipe_session(buffer_limit: 4)
+    assert_equal 0, session.buffer_discarded_bytes
+    session.buffer = "abcdef"
+    assert_equal "cdef", session.buffer
+    assert_equal 2, session.buffer_discarded_bytes
+    session.buffer_limit = 2
+    assert_equal "ef", session.buffer
+    assert_equal 4, session.buffer_discarded_bytes
+    assert_equal 1, session.expect("e", timeout: 0)
+    assert_equal "f", session.clear_buffer
+    session.close
+    assert_equal 4, session.buffer_discarded_bytes
+    refute_respond_to session, :buffer_discarded_bytes=
+  end
+
+  def test_invalid_limit_and_buffer_leave_accounting_unchanged
+    session, = pipe_session(buffer_limit: 4)
+    session.buffer = "abcdef"
+    assert_raises(ArgumentError) { session.buffer_limit = 0 }
+    assert_raises(ArgumentError) { session.buffer = nil }
+    assert_equal "cdef", session.buffer
+    assert_equal 2, session.buffer_discarded_bytes
+    session.buffer_limit = nil
+    session.buffer = "unlimited"
+    assert_equal 2, session.buffer_discarded_bytes
+  end
+
+  def test_continuous_output_keeps_a_bounded_window_and_complete_log
+    session, writer = pipe_session(buffer_limit: 64)
+    logged = 0
+    session.log_to { |data| logged += data.bytesize }
+    32.times do
+      writer.write("x" * 4096)
+      assert_nil session.expect("missing", timeout: 0)
+      assert_equal 64, session.buffer.bytesize
+    end
+    assert_equal 131_072, logged
+    assert_equal logged - 64, session.buffer_discarded_bytes
+  end
+
+  def test_preserved_match_does_not_count_as_discard
+    session, = pipe_session(buffer_limit: 4, preserve_buffer: true)
+    session.buffer = "abcdef"
+    2.times { assert_equal 1, session.expect("ef", timeout: 0) }
+    assert_equal "cdef", session.buffer
+    assert_equal 2, session.buffer_discarded_bytes
+  end
+
+  def test_relay_tail_is_only_counted_when_matching_applies_the_limit
+    session, writer = pipe_session(buffer_limit: 2)
+    output = StringIO.new
+    session.listeners = [output]
+    session.on_sequence("STOP")
+    writer.write("prefixSTOPtail")
+    assert_same session, Expect.interconnect(session, timeout: 1)
+    assert_equal "prefix", output.string
+    assert_equal "tail", session.buffer
+    assert_equal 0, session.buffer_discarded_bytes
+    assert_equal 1, session.expect("il", timeout: 0)
+    assert_equal 2, session.buffer_discarded_bytes
+    session.expect(timeout: 0)
+    assert_equal 2, session.buffer_discarded_bytes
+  end
+
+  def test_logging_failure_preserves_the_retained_input_and_discard_count
+    session, writer = pipe_session(buffer_limit: 4)
+    failure = IOError.new("log failed")
+    session.log_to { raise failure }
+    writer.write("abcdef")
+    assert_same failure, session.expect_result("ef", timeout: 1).error
+    assert_equal "cdef", session.buffer
+    assert_equal 2, session.buffer_discarded_bytes
+    session.log_output = nil
+    assert_equal 1, session.expect("ef", timeout: 0)
+    assert_equal 2, session.buffer_discarded_bytes
+  end
+end

data/test/cleanup_test.rb

@@ -3,6 +3,94 @@
 require_relative "test_helper"
 
 class CleanupTest < ExpectTest
+  def test_failed_open_initialization_attempts_all_owned_handles_and_preserves_validation_error
+    reader, writer = IO.pipe
+    @ios.push(reader, writer)
+    reader.stub(:close, -> { raise IOError, "reader close failed" }) do
+      error = assert_raises(ArgumentError) { Expect.open(reader, writer: writer, own: true, unknown: true) }
+      assert_match(/unknown/, error.message)
+      assert writer.closed?
+    end
+  end
+
+  def test_failed_new_initialization_attempts_all_pty_handles_and_preserves_validation_error
+    master, slave = PTY.open
+    @ios.push(master, slave)
+    PTY.stub(:open, [master, slave]) do
+      master.stub(:close, -> { raise IOError, "master close failed" }) do
+        error = assert_raises(ArgumentError) { Expect.new(unknown: true) }
+        assert_match(/unknown/, error.message)
+        assert slave.closed?
+      end
+    end
+  end
+
+  def test_failed_open_closes_real_owned_handles_when_an_argument_is_not_io
+    [true, false].each do |invalid_reader|
+      reader, writer = IO.pipe
+      @ios.push(reader, writer)
+      invalid = Object.new
+      invalid.define_singleton_method(:close) { raise "invalid IO must not be closed" }
+      incoming = invalid_reader ? invalid : reader
+      outgoing = invalid_reader ? writer : invalid
+      assert_raises(ArgumentError) { Expect.open(incoming, writer: outgoing, own: true) }
+      assert(invalid_reader ? writer.closed? : reader.closed?)
+    end
+  end
+
+  def test_open_block_error_is_preserved_when_owned_cleanup_also_fails
+    [ArgumentError.new("block failed"), Interrupt.new("interrupted"), SystemExit.new(17)].each do |failure|
+      reader, writer = IO.pipe
+      @ios.push(reader, writer)
+      reader.stub(:close, -> { raise IOError, "reader close failed" }) do
+        error = assert_raises(failure.class) do
+          Expect.open(reader, writer: writer, own: true) { raise failure }
+        end
+        assert_same failure, error
+        assert writer.closed?
+      end
+    end
+  end
+
+  def test_open_block_break_still_reports_cleanup_failure
+    reader, writer = IO.pipe
+    @ios.push(reader, writer)
+    failure = IOError.new("reader close failed")
+    reader.stub(:close, -> { raise failure }) do
+      error = assert_raises(IOError) { Expect.open(reader, writer: writer, own: true) { break :done } }
+      assert_same failure, error
+      assert writer.closed?
+    end
+  end
+
+  def test_spawn_block_error_is_preserved_and_child_reaped_when_cleanup_also_fails
+    session = stubborn_child
+    failure = ArgumentError.new("block failed")
+    Expect.stub(:new, session) do
+      session.stub(:spawn, session) do
+        session.to_io.stub(:close, -> { raise IOError, "reader close failed" }) do
+          error = assert_raises(ArgumentError) { Expect.spawn("already started") { raise failure } }
+          assert_same failure, error
+          assert_nil session.pid
+        end
+      end
+    end
+  end
+
+  def test_graceful_close_preserves_logging_error_when_handle_cleanup_also_fails
+    session = stubborn_child
+    failure = ArgumentError.new("log failed")
+    session.log_output = ->(_) { raise failure }
+    session.to_io.stub(:wait_readable, true) do
+      session.to_io.stub(:read_nonblock, "last output") do
+        session.to_io.stub(:close, -> { raise IOError, "reader close failed" }) do
+          assert_same failure, assert_raises(ArgumentError) { session.close(graceful: true) }
+          assert_nil session.pid
+        end
+      end
+    end
+  end
+
   def test_close_handles_attempts_every_owned_handle_and_preserves_first_error
     reader, writer = IO.pipe
     extra, peer = IO.pipe

data/test/deadline_test.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class DeadlineTest < ExpectTest
+  def test_absolute_deadline_caps_timeout_resets_from_incoming_data
+    session, writer = pipe_session(reset_timeout_on_read: true)
+    with_clock([[4, writer, "."], [8, writer, "."], [12, writer, "done"]]) do |clock|
+      result = session.expect_result("done", timeout: 5, deadline: 10)
+      assert result.timeout?
+      assert_equal 10, clock[0]
+      assert_equal "..", session.buffer
+    end
+  end
+
+  def test_class_api_and_nil_timeout_use_the_absolute_deadline
+    session, writer = pipe_session
+    with_clock([[4, writer, "ready"]]) do |clock|
+      assert_equal 1, Expect.expect("ready", from: session, timeout: nil, deadline: 5)
+      result = Expect.expect_result("missing", from: session, timeout: nil, deadline: 5)
+      assert result.timeout?
+      assert_equal 5, clock[0]
+    end
+  end
+
+  def test_shorter_relative_timeout_still_wins
+    session, = pipe_session
+    with_clock do |clock|
+      assert session.expect_result("missing", timeout: 2, deadline: 10).timeout?
+      assert_equal 2, clock[0]
+    end
+  end
+
+  def test_continuing_match_cannot_extend_the_hard_deadline
+    session, = pipe_session
+    session.buffer = "first second"
+    with_clock do |clock|
+      result = session.expect_result(timeout: 10, deadline: 5) do
+        on("first") do
+          clock[0] = 6
+          Expect.continue
+        end
+        on("second") { flunk "must not consume text after the deadline" }
+      end
+      assert result.timeout?
+      assert_equal " second", session.buffer
+    end
+  end
+
+  def test_timeout_callback_cannot_restart_an_expired_hard_deadline
+    session, = pipe_session
+    calls = 0
+    with_clock do |clock|
+      result = session.expect_result(timeout: 3, deadline: 5) do
+        timeout do
+          calls += 1
+          Expect.continue
+        end
+      end
+      assert result.timeout?
+      assert_equal 2, calls
+      assert_equal 5, clock[0]
+    end
+  end
+
+  def test_expired_deadline_does_not_scan_or_read_and_preserves_input
+    session, writer = pipe_session
+    session.buffer = "buffered"
+    writer.write("unread")
+    with_clock do |clock|
+      clock[0] = 5
+      assert session.expect_result("buffered", timeout: 0, deadline: 5).timeout?
+      assert_equal "buffered", session.buffer
+      assert_equal "unread", session.to_io.read_nonblock(6)
+    end
+  end
+
+  def test_zero_relative_timeout_still_polls_with_a_future_hard_deadline
+    session, writer = pipe_session
+    writer.write("ready")
+    assert_equal 1, session.expect("ready", timeout: 0, deadline: Expect.monotonic + 1)
+  end
+
+  def test_repeated_interruptions_cannot_extend_a_deadline
+    session, = pipe_session
+    clock = [0]
+    Expect.stub(:monotonic, -> { clock[0] }) do
+      IO.stub(:select, lambda { |*|
+        clock[0] += 1
+        raise Errno::EINTR
+      }) do
+        assert session.expect_result("missing", deadline: 3).timeout?
+      end
+      assert_equal 3, clock[0]
+    end
+  end
+
+  def test_known_eof_events_are_delivered_before_timeout_of_live_sources
+    ended, = pipe_session
+    live, = pipe_session
+    ended.close
+    live.buffer = "ready"
+    seen = []
+    with_clock do
+      result = Expect.expect_result(from: [ended, live], deadline: 0) do
+        on("ready") { flunk "deadline already expired" }
+        eof(from: ended) do
+          seen << :eof
+          Expect.continue
+        end
+        timeout { |sessions| seen << sessions }
+      end
+      assert result.timeout?
+      assert_same live, result.session
+      assert_equal [:eof, [live]], seen
+      assert_equal "ready", live.buffer
+    end
+  end
+
+  def test_all_known_eof_returns_eof_even_at_the_hard_deadline
+    first, = pipe_session
+    second, = pipe_session
+    [first, second].each(&:close)
+    seen = []
+    with_clock do
+      result = Expect.expect_result(from: [first, second], deadline: 0) do
+        eof do |session|
+          seen << session
+          Expect.continue
+        end
+        timeout { flunk "all sources ended" }
+      end
+      assert result.eof?
+      assert_equal [first, second], seen
+    end
+  end
+
+  def test_deadline_reached_during_regexp_does_not_consume_the_match
+    session, = pipe_session
+    session.buffer = "ready"
+    pattern = Regexp.new("ready")
+    match = pattern.method(:match)
+    with_clock do |clock|
+      pattern.stub(:match, lambda { |text|
+        clock[0] = 5
+        match.call(text)
+      }) do
+        assert session.expect_result(pattern, deadline: 5).timeout?
+      end
+      assert_equal "ready", session.buffer
+    end
+  end
+
+  def test_preserved_timeout_at_hard_deadline_still_dispatches_all_known_eof
+    first, = pipe_session
+    second, = pipe_session
+    [first, second].each(&:close)
+    first.buffer = "ready"
+    seen = []
+    with_clock do |clock|
+      result = Expect.expect_result(from: [first, second], deadline: 5) do
+        on("ready") do
+          clock[0] = 5
+          Expect.continue(reset_timeout: false)
+        end
+        eof do |session|
+          seen << session
+          Expect.continue(reset_timeout: false)
+        end
+        timeout { seen << :timeout }
+      end
+      assert result.eof?
+      assert_equal [first, second], seen
+    end
+  end
+
+  def test_preserved_timeout_at_hard_deadline_only_times_out_live_sources
+    ended, = pipe_session
+    live, = pipe_session
+    ended.close
+    ended.buffer = "ready"
+    seen = []
+    with_clock do |clock|
+      result = Expect.expect_result(from: [ended, live], deadline: 5) do
+        on("ready") do
+          clock[0] = 5
+          Expect.continue(reset_timeout: false)
+        end
+        eof(from: ended) do
+          seen << :eof
+          Expect.continue(reset_timeout: false)
+        end
+        timeout { |sessions| seen << sessions }
+      end
+      assert result.timeout?
+      assert_same live, result.session
+      assert_equal [:eof, [live]], seen
+    end
+  end
+
+  def test_invalid_deadlines_are_rejected_before_the_definition_or_io
+    session, writer = pipe_session
+    writer.write("ready")
+    [Float::INFINITY, -Float::INFINITY, Float::NAN, "invalid"].each do |deadline|
+      assert_raises(ArgumentError) do
+        session.expect_result(deadline: deadline) { flunk "invalid deadline must reject before registration" }
+      end
+    end
+    assert_equal "ready", session.to_io.read_nonblock(5)
+  end
+
+  private
+
+  # 虚拟时间只控制等待，数据仍经真实管道；精确断言上限，不依赖线程调度和 sleep。
+  def with_clock(events = [])
+    clock = [0.0]
+    pending = events.dup
+    poll = IO.method(:select)
+    select = lambda do |readers, writers, errors, timeout|
+      due = timeout && (clock[0] + timeout)
+      if pending.any? && (!due || pending.first[0] <= due)
+        at, writer, data = pending.shift
+        clock[0] = at
+        writer.write(data)
+        poll.call(readers, writers, errors, 0)
+      else
+        raise "unbounded wait without input" unless due
+
+        clock[0] = due
+        nil
+      end
+    end
+    Expect.stub(:monotonic, -> { clock[0] }) do
+      IO.stub(:select, select) { yield clock }
+    end
+  end
+end