expect-pty 0.3.2 → 0.3.3

data/lib/expect.rb

@@ -3,7 +3,6 @@
 require "pty"
 require "io/console"
 require "io/wait"
-require "shellwords"
 require "stringio"
 require "forwardable"
 require_relative "expect/version"
@@ -62,11 +61,19 @@ class Expect
     def spawn(*command, env: {}, chdir: nil, **)
       session = new(**)
       session.spawn(*command, env: env, chdir: chdir)
+      spawned = true
       return session unless block_given?
 
       yield session
+    rescue Exception # rubocop:disable Lint/RescueException -- 记录本次作用域的失败，清理后原样传播，包括非 StandardError 异常。
+      failed = true
+      raise
     ensure
-      session&.close if block_given? || (session && !session.pid)
+      if session && (block_given? || !spawned)
+        session.__send__(:cleanup_preserving_failure, failed) do
+          session.close(graceful: spawned && session.graceful_close?)
+        end
+      end
     end
 
     # 适配已有 IO；own: true 接管关闭责任，初始化失败也释放接管的读写端。
@@ -77,11 +84,14 @@ class Expect
       return session unless block_given?
 
       yield session
+    rescue Exception # rubocop:disable Lint/RescueException -- 初始化和块异常均须保留，清理失败不能替换原始原因。
+      failed = true
+      raise
     ensure
-      if initialized
-        session.close if block_given?
-      elsif own
-        [io, writer].uniq.each { |handle| handle.close if handle.is_a?(IO) && !handle.closed? }
+      if session && (block_given? || !initialized)
+        session.__send__(:cleanup_preserving_failure, failed) do
+          session.close(graceful: initialized && session.graceful_close?)
+        end
       end
     end
 
@@ -173,11 +183,11 @@ class Expect
     @tty_name = slave.path
     spawn(*command, env: env, chdir: chdir) unless command.empty?
     initialized = true
+  rescue Exception # rubocop:disable Lint/RescueException -- 构造异常时也要关闭已创建的资源并回收已启动的子进程。
+    failed = true
+    raise
   ensure
-    unless initialized
-      master&.close unless master&.closed?
-      slave&.close unless slave&.closed?
-    end
+    cleanup_preserving_failure(failed) { close(graceful: false) } if @resources && !initialized
   end
 
   # 在新控制终端中执行命令并同步确认 exec 结果；同一会话只能启动一次。
@@ -382,82 +392,6 @@ class Expect
     count
   end
 
-  # 读取当前日志目标，可能为库打开的文件、借用的 IO、回调或 nil。
-  attr_reader :log_output
-
-  # 替换借用的日志目标或停止日志；先校验新目标，失败时保留旧目标。
-  def log_output=(target)
-    unless target.nil? || target.respond_to?(:write) || target.respond_to?(:call)
-      raise ArgumentError, "log output must support write or call, or be nil"
-    end
-
-    replace_log(target)
-  end
-
-  # 打开追加/覆盖日志文件，或注册接收字节的日志块；同一次只能指定一种目标。
-  def log_to(target = nil, mode: "a", &block)
-    raise ArgumentError, "provide a log target or a block, not both" if block && target
-
-    target = block if block
-    if target.respond_to?(:to_path) || target.is_a?(String)
-      raise ArgumentError, "log mode must be a or w" unless %w[a w].include?(mode)
-
-      # 库打开的文件由 SessionResources 持有，替换日志或关闭会话时释放；外部 IO 只借用。
-      replace_log(File.open(target, "#{mode}b", 0o600), owned: true)
-    else
-      raise ArgumentError, "provide a log target or a block" unless target
-
-      self.log_output = target
-    end
-  end
-
-  # 向当前日志目标补写内容，支持 IO 和回调，不发送给子进程或监听器。
-  def write_log(*objects)
-    target = log_output
-    return unless target
-
-    data = objects.map { |object| object.to_s.b }.join
-    target.respond_to?(:call) ? target.call(data) : emit(target, data)
-  end
-
-  # 返回监听器列表副本，避免外部原地修改转发关系。
-  def listeners = @listeners.dup
-
-  # 校验所有监听器均可写后一次性替换列表，外部数组后续修改不会影响会话。
-  def listeners=(outputs)
-    outputs = Array(outputs)
-    raise ArgumentError, "listeners must support write" unless outputs.all? { |output| output.respond_to?(:write) }
-
-    @listeners = outputs.dup
-  end
-
-  # 查询可恢复的终端模式字符串，或通过系统 stty 设置模式；参数按数组传递，不经 shell。
-  def stty(*modes)
-    return "" unless tty?
-
-    modes = modes.flat_map { |mode| Shellwords.split(mode.to_s) }
-    modes = ["-g"] if modes.empty?
-    reader, sink = IO.pipe
-    child = Process.spawn("stty", *modes, in: to_io, out: sink, err: sink)
-    sink.close
-    output = reader.read
-    _, status = Process.waitpid2(child)
-    raise IOError, "stty failed: #{output.strip}" unless status.success?
-
-    output.strip
-  ensure
-    reader&.close unless reader&.closed?
-    sink&.close unless sink&.closed?
-  end
-
-  # 读取终端的 [行数, 列数]。
-  def winsize = to_io.winsize
-
-  # 更新终端尺寸，由内核通知前台进程。
-  def winsize=(size)
-    to_io.winsize = size
-  end
-
   # 轮询回收状态直到进程退出或期限到达；返回 Process::Status 或 nil，超时不丢弃 PID。
   def wait(timeout: nil)
     period = Expect.duration(timeout)
@@ -501,12 +435,22 @@ class Expect
   def close(graceful: graceful_close?)
     soft_close if graceful
     nil
+  rescue Exception # rubocop:disable Lint/RescueException -- 软关闭的原始异常在硬关闭兜底后继续传播。
+    failed = true
+    raise
   ensure
-    hard_close
+    cleanup_preserving_failure(failed) { hard_close }
   end
 
   private
 
+  # 仅在本次生命周期已有异常时抑制常规清理错误；调用者 rescue 中的旧异常不算本次失败。
+  def cleanup_preserving_failure(failed)
+    yield
+  rescue IOError, SystemCallError
+    raise unless failed
+  end
+
   # 共用的进程关闭流程；force 控制是否允许 KILL，只有资源创建者能够操作直属子进程。
   def finish_close(timeout:, term_timeout:, force:)
     failure = nil
@@ -555,10 +499,11 @@ class Expect
 
   # 统一初始化 PTY 与已有 IO 会话，复制配置并注册不直接捕获会话的资源终结器。
   def initialize_session(reader, writer:, slave: nil, own: false, **)
+    # 先登记所有权，后续校验失败也使用同一个资源对象逐个清理所属 IO。
+    @resources = SessionResources.new(reader, writer: writer, slave: slave, own: own)
     raise ArgumentError, "reader must be a real IO" unless reader.is_a?(IO) && !reader.closed?
     raise ArgumentError, "writer must be a real IO" unless writer.is_a?(IO) && !writer.closed?
 
-    @resources = SessionResources.new(reader, writer: writer, slave: slave, own: own)
     @pty = reader.tty?
     @slave = slave
     @configuration = Configuration.new(**self.class.configuration.to_h, **)
@@ -646,47 +591,6 @@ class Expect
     @buffer = @buffer.byteslice(-limit, limit) if limit&.positive? && @buffer.bytesize > limit
   end
 
-  # 按各自开关将接收字节转发到 stdout 和监听器，不重复写日志。
-  def propagate(data)
-    emit($stdout, data) if log_stdout?
-    @listeners.each { |listener| emit(listener, data) } if log_listeners?
-  end
-
-  # 向目标写入并在支持时立即 flush，使日志和终端输出及时可见。
-  def emit(target, data)
-    offset = 0
-    while offset < data.bytesize
-      count = target.write(data.byteslice(offset..))
-      unless count.is_a?(Integer) && count.positive? && count <= data.bytesize - offset
-        raise IOError, "write must return the number of accepted bytes"
-      end
-
-      offset += count
-    end
-    target.flush if target.respond_to?(:flush)
-  end
-
-  # 按诊断级别向 stderr 输出会话标识和消息。
-  def trace(message, level: 1)
-    warn("#{inspect}: #{message}") if debug_level >= level
-  end
-
-  # 交接日志目标和所有权，只关闭库拥有的旧文件；失败时释放新打开的文件。
-  def replace_log(target, owned: false)
-    previous = log_output
-    # 重复赋值同一目标时保留原所有权，防止将库打开的文件误变成借用资源。
-    return target if previous.equal?(target)
-
-    previous.close if @resources.owned_log && previous && !previous.closed?
-    # 终结器只持有所属文件；借用回调可能捕获会话，不能让它经资源对象成为 GC 根。
-    @resources.owned_log = owned ? target : nil
-    @log_output = target
-    target
-  rescue Exception # rubocop:disable Lint/RescueException -- 替换失败时仍释放刚打开的文件。
-    target.close if owned && target && !target.closed?
-    raise
-  end
-
   # 仅由资源创建者向仍未回收的子进程发送信号；若进程刚好退出，则尝试回收。
   def signal_child(signal)
     return unless alive? && @resources.owner == Process.pid
@@ -697,4 +601,6 @@ class Expect
   end
 end
 
+require_relative "expect/logging"
+require_relative "expect/terminal"
 require_relative "expect/interaction"

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/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/pattern_offset_test.rb

@@ -16,8 +16,10 @@ class PatternOffsetTest < ExpectTest
     ]
     session, = pipe_session
     cases.each do |text, regexp, offset, length, captures|
-      bytes = text.b
+      # 扫描只读调用者输入；省去正则副本后也不能改变编码标记或冻结字符串。
+      bytes = text.b.freeze
       assert_equal [offset, length, captures], Expect::Pattern.new(value: regexp).locate(bytes)
+      assert_equal Encoding::BINARY, bytes.encoding
       session.buffer = bytes
       result = session.expect_result(regexp, timeout: 0)
       assert_equal bytes.byteslice(0, offset), result.before

data/test/process_test.rb

@@ -77,6 +77,14 @@ class ProcessTest < ExpectTest
     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
@@ -228,6 +236,17 @@ class ProcessTest < ExpectTest
     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
@@ -242,4 +261,31 @@ class ProcessTest < ExpectTest
     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

data/test/release_test.rb

@@ -36,11 +36,11 @@ class ReleaseTest < Minitest::Test
 
   def test_rubygems_only_publishes_the_verified_copy_without_github
     with_package do |_release, artifact|
+      commit_package_source
       release = Release.new(artifact: artifact, rubygems_only: true)
       bytes = File.binread(artifact)
       checksum = Digest::SHA256.hexdigest(bytes)
       published = false
-      capture = ->(*arguments) { arguments.include?("rev-parse") ? "verified" : "" }
       get = lambda do |path|
         if path.start_with?("/downloads/")
           Struct.new(:code, :body).new("200", bytes)
@@ -58,19 +58,17 @@ class ReleaseTest < Minitest::Test
         refute_equal File.expand_path(artifact), candidate
         published = true
       end
-      release.stub(:capture, capture) do
-        release.stub(:get, get) do
-          release.stub(:system, push) do
-            release.stub(:github, ->(*) { flunk "RubyGems-only release contacted GitHub" }) do
-              release.stub(:publish_github, -> { flunk "RubyGems-only release published to GitHub" }) do
-                [nil, "true"].each do |github_actions|
-                  with_environment("GITHUB_ACTIONS" => github_actions,
-                                   "GEM_HOST_API_KEY" => (github_actions ? "test-only-api-key" : nil)) do
-                    published = false
-                    output, = capture_io { release.run }
-                    assert_includes output, "SHA256 verified"
-                    assert published
-                  end
+      release.stub(:get, get) do
+        release.stub(:system, push) do
+          release.stub(:github, ->(*) { flunk "RubyGems-only release contacted GitHub" }) do
+            release.stub(:publish_github, -> { flunk "RubyGems-only release published to GitHub" }) do
+              [nil, "true"].each do |github_actions|
+                with_environment("GITHUB_ACTIONS" => github_actions,
+                                 "GEM_HOST_API_KEY" => (github_actions ? "test-only-api-key" : nil)) do
+                  published = false
+                  output, = capture_io { release.run }
+                  assert_includes output, "SHA256 verified"
+                  assert published
                 end
               end
             end
@@ -107,9 +105,11 @@ class ReleaseTest < Minitest::Test
 
   def test_rubygems_only_rechecks_source_after_verification
     with_package do |_release, artifact|
+      commit_package_source
       release = Release.new(artifact: artifact, rubygems_only: true)
       statuses = ["", " M payload.rb"]
-      capture = ->(*arguments) { arguments.include?("rev-parse") ? "verified" : statuses.shift }
+      original = release.method(:capture)
+      capture = ->(*arguments) { arguments.include?("rev-parse") ? original.call(*arguments) : statuses.shift }
       release.stub(:capture, capture) do
         release.stub(:get, ->(*) { flunk "changed source contacted RubyGems" }) do
           capture_io do
@@ -127,6 +127,53 @@ class ReleaseTest < Minitest::Test
     end
   end
 
+  def test_rejects_ignored_source_collected_by_the_package_glob
+    with_package do |_release, artifact|
+      commit_package_source
+      FileUtils.mkdir_p("lib")
+      File.write("lib/local_only.rb", "puts :local_only\n")
+      File.write(".git/info/exclude", "lib/local_only.rb\n", mode: "a")
+      rebuild_package
+      assert_empty git("status", "--porcelain")
+
+      error = publishing_source_error(artifact)
+      assert_match "not in release commit: lib/local_only.rb", error.message
+      # 提交前的 dry-run 仍可检验候选包，但不能以此证明发布来源。
+      capture_io { Release.new(artifact: artifact, dry_run: true).run }
+    end
+  end
+
+  def test_rejects_source_changes_hidden_from_git_status
+    with_package do |_release, artifact|
+      commit_package_source
+      git("update-index", "--assume-unchanged", "payload.rb")
+      File.binwrite("payload.rb", "puts :changed\n\n")
+      rebuild_package
+      assert_empty git("status", "--porcelain")
+      assert_match "differs from release commit: payload.rb", publishing_source_error(artifact).message
+    end
+  end
+
+  def test_rejects_executable_mode_changes_hidden_from_git_status
+    with_package do |_release, artifact|
+      commit_package_source
+      git("config", "core.filemode", "false")
+      File.chmod(0o755, "payload.rb")
+      rebuild_package
+      assert_empty git("status", "--porcelain")
+      assert_match "permissions differ from release commit: payload.rb", publishing_source_error(artifact).message
+    end
+  end
+
+  def test_rejects_altered_homepage_metadata
+    with_package do |release, _artifact|
+      spec = Gem::Specification.load(File.expand_path("expect-pty.gemspec")).dup
+      spec.homepage = "https://example.invalid/altered"
+      capture_io { Gem::Package.build(spec) }
+      assert_match "metadata", assert_raises(RuntimeError) { release.send(:verify_package) }.message
+    end
+  end
+
   def test_rejects_different_installation_metadata_even_with_identical_source_files
     with_package do |release, _artifact|
       expected = Gem::Specification.load(File.expand_path("expect-pty.gemspec")).dup
@@ -214,6 +261,37 @@ class ReleaseTest < Minitest::Test
 
   private
 
+  def git(*)
+    output, error, status = Open3.capture3("git", *)
+    assert status.success?, error
+    output
+  end
+
+  def commit_package_source
+    git("init", "--quiet")
+    git("config", "core.hooksPath", File::NULL)
+    File.write(".git/info/exclude", "*.gem\ntmp/\n")
+    git("add", "--", "payload.rb", "CHANGELOG.md", "expect-pty.gemspec")
+    git("-c", "user.name=Release Test", "-c", "user.email=release-test@example.invalid",
+        "-c", "commit.gpgsign=false", "commit", "--quiet", "-m", "Release fixture")
+  end
+
+  def rebuild_package
+    # Gem::Specification.load 会缓存已加载的 gemspec；重新执行才能看到新的 glob 文件。
+    Gem::Specification.reset
+    spec = Gem::Specification.load(File.expand_path("expect-pty.gemspec"))
+    capture_io { Gem::Package.build(spec) }
+  end
+
+  def publishing_source_error(artifact)
+    release = Release.new(artifact: artifact, rubygems_only: true)
+    release.stub(:get, ->(*) { flunk "uncommitted package content reached RubyGems" }) do
+      error = nil
+      capture_io { error = assert_raises(RuntimeError) { release.run } }
+      error
+    end
+  end
+
   # 发布测试显式控制凭据环境，避免本机登录状态或 CI 标记影响用例结果。
   def with_environment(values)
     previous = values.to_h { |name, _value| [name, ENV.fetch(name, nil)] }
@@ -238,7 +316,7 @@ class ReleaseTest < Minitest::Test
             spec.authors = ["Test"]
             spec.license = "MIT"
             spec.homepage = "https://github.com/gatework/expect-ruby"
-            spec.files = ["payload.rb", "CHANGELOG.md", "expect-pty.gemspec"]
+            spec.files = ["payload.rb", "CHANGELOG.md", "expect-pty.gemspec"] + Dir["lib/**/*.rb"]
           end
         RUBY
         artifact = nil