expect-pty 0.3.1 → 0.3.3

data/test/cleanup_test.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+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
+    @ios.push(reader, writer, extra, peer)
+    resources = Expect::SessionResources.new(reader, writer: writer, slave: extra, own: true)
+    failure = IOError.new("reader close failed")
+    reader.stub(:close, -> { raise failure }) do
+      assert_same failure, assert_raises(IOError) { resources.close_handles }
+      assert writer.closed?
+      assert extra.closed?
+    end
+    resources.close_handles
+    assert reader.closed?
+    resources.close_handles
+  end
+
+  def test_hard_close_finishes_wrappers_log_and_child_after_handle_failure
+    session = stubborn_child
+    pid = session.pid
+    first, = pipe_session
+    second, = pipe_session
+    session.instance_variable_set(:@interact_inputs, { first.to_io => first, second.to_io => second })
+    Dir.mktmpdir do |dir|
+      log = session.log_to(File.join(dir, "owned.log"))
+      failure = IOError.new("handle close failed")
+      session.to_io.stub(:close, -> { raise failure }) do
+        first.stub(:close, ->(**) { raise IOError, "wrapper close failed" }) do
+          error = assert_raises(IOError) { bounded { session.hard_close(timeout: 0.01) } }
+          assert_same failure, error
+          assert second.closed?
+          refute second.to_io.closed?, "borrowed wrapper IO must remain open"
+          assert log.closed?
+          assert_nil session.log_output
+          assert_nil session.pid
+          assert_equal Signal.list.fetch("KILL"), session.process_status.termsig
+          assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
+        end
+      end
+    end
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_owned_log_close_failure_is_visible_after_child_reaping_and_retryable
+    session = stubborn_child
+    Dir.mktmpdir do |dir|
+      log = session.log_to(File.join(dir, "owned.log"))
+      log.stub(:close, -> { raise IOError, "log close failed" }) do
+        assert_raises(IOError) { bounded { session.hard_close(timeout: 0.01) } }
+        assert_nil session.pid
+        assert_same log, session.log_output
+      end
+      status = session.hard_close(timeout: 0)
+      assert_same session.process_status, status
+      assert log.closed?
+      assert_nil session.log_output
+    end
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_explicit_close_inside_rescue_does_not_hide_a_new_cleanup_error
+    session, = pipe_session(own: true)
+    failure = IOError.new("close failed inside caller rescue")
+    begin
+      raise ArgumentError, "already handled"
+    rescue ArgumentError
+      session.to_io.stub(:close, -> { raise failure }) do
+        assert_same failure, assert_raises(IOError) { session.hard_close(timeout: 0) }
+      end
+    end
+  end
+
+  def test_unexpected_process_error_is_not_replaced_by_cleanup_failure
+    session = stubborn_child
+    failure = RuntimeError.new("process wait failed")
+    session.to_io.stub(:close, -> { raise IOError, "close failed" }) do
+      session.stub(:wait, ->(**) { raise failure }) do
+        assert_same failure, assert_raises(RuntimeError) { session.hard_close(timeout: 0) }
+      end
+    end
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_soft_close_handle_failure_still_sends_term_but_never_kill
+    session = stubborn_child
+    signals = []
+    original = Process.method(:kill)
+    Process.stub(:kill, lambda { |signal, pid|
+      signals << signal
+      original.call(signal, pid)
+    }) do
+      session.to_io.stub(:close, -> { raise Errno::EIO, "close failed" }) do
+        assert_raises(Errno::EIO) { bounded { session.soft_close(timeout: 0, term_timeout: 0) } }
+      end
+    end
+    assert_equal ["TERM"], signals
+    assert session.alive?
+    assert session.closed?
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_finalizer_reaps_after_both_handle_and_log_close_fail
+    session = stubborn_child
+    pid = session.pid
+    resources = session.instance_variable_get(:@resources)
+    log_attempted = false
+    Dir.mktmpdir do |dir|
+      log = session.log_to(File.join(dir, "owned.log"))
+      session.to_io.stub(:close, -> { raise IOError, "handle failed" }) do
+        log.stub(:close, lambda {
+          log_attempted = true
+          raise Errno::EIO, "log failed"
+        }) do
+          bounded { resources.finalize }
+        end
+      end
+      assert log_attempted
+      assert_nil resources.pid
+      bounded do
+        loop do
+          Process.kill(0, pid)
+          sleep 0.005
+        rescue Errno::ESRCH
+          break
+        end
+      end
+    end
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  def test_non_owner_cleanup_never_signals_and_finalizer_leaves_handles_alone
+    session = stubborn_child
+    resources = session.instance_variable_get(:@resources)
+    Process.stub(:pid, -1) do
+      Process.stub(:kill, ->(*) { flunk "non-owner sent a signal" }) do
+        resources.finalize
+        refute session.to_io.closed?
+        assert_nil session.hard_close(timeout: 0)
+      end
+    end
+    assert session.alive?
+  ensure
+    session&.hard_close(timeout: 0)
+  end
+
+  private
+
+  def stubborn_child
+    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)
+    session
+  end
+end

data/test/configuration_test.rb

@@ -56,6 +56,49 @@ class ConfigurationTest < ExpectTest
     assert_equal 2, Expect.configuration.timeout
   end
 
+  def test_concurrent_configure_updates_are_serialized
+    subclass = Class.new(Expect)
+    entered = Queue.new
+    second_started = Queue.new
+    release = Queue.new
+    first = Thread.new do
+      subclass.configure do |config|
+        entered << true
+        release.pop
+        config.timeout = 1
+      end
+    end
+    entered.pop
+    second = Thread.new do
+      second_started << true
+      subclass.configure(debug_level: 2)
+    end
+    second_started.pop
+    # 第一轮尚未发布时，第二轮不能从同一旧快照完成更新。
+    refute second.join(0.05), "concurrent configure published before the first update finished"
+    release << true
+    first.value
+    second.value
+    assert_equal 1, subclass.configuration.timeout
+    assert_equal 2, subclass.configuration.debug_level
+  ensure
+    release&.push(true)
+    first&.join
+    second&.join
+  end
+
+  def test_nested_configure_fails_without_publishing_partial_changes
+    subclass = Class.new(Expect)
+    previous = subclass.configuration
+    assert_raises(ThreadError) do
+      subclass.configure do |config|
+        config.timeout = 1
+        subclass.configure(debug_level: 2)
+      end
+    end
+    assert_same previous, subclass.configuration
+  end
+
   def test_attribute_validation_preserves_the_current_value_and_buffer
     session, = pipe_session(buffer_limit: 8, timeout: 1, write_timeout: 2, debug_level: 1)
     session.buffer = "contents"

data/test/io_test.rb

@@ -133,6 +133,41 @@ class IOTest < ExpectTest
     assert_equal 1, session.expect("ABC", timeout: 1)
   end
 
+  def test_send_slow_zero_delay_only_polls_and_later_reply_remains_readable
+    client, peer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(client, peer)
+    session = Expect.open(client, log_stdout: false)
+    @sessions << session
+    waits = []
+    original = client.method(:wait_readable)
+    client.stub(:wait_readable, lambda { |timeout|
+      waits << timeout
+      original.call(0)
+    }) do
+      assert_equal 8, session.send_slow("a中😀", delay: 0)
+    end
+    assert_equal [0, 0, 0], waits
+    assert_equal("a中😀".b, bounded { peer.read(8) })
+    peer.write("late reply")
+    assert_equal 1, session.expect("late reply", timeout: 1)
+    assert_empty session.buffer
+  end
+
+  def test_send_slow_preserves_character_delay_and_write_timeout
+    session, = pipe_session
+    calls = []
+    failure = Expect::WriteTimeout.new(bytes_written: 0)
+    session.stub(:sleep, ->(duration) { calls << [:sleep, duration] }) do
+      session.stub(:write, lambda { |data|
+        calls << [:write, data]
+        raise failure
+      }) do
+        assert_same failure, assert_raises(Expect::WriteTimeout) { session.send_slow("中b", delay: 0.25) }
+      end
+    end
+    assert_equal [[:sleep, 0.25], [:write, "中"]], calls
+  end
+
   def test_large_bidirectional_write_does_not_deadlock
     session = child("STDIN.binmode; STDOUT.binmode; loop { print STDIN.readpartial(4096) }", raw_pty: true,
                                                                                              write_timeout: 3)

data/test/pattern_offset_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class PatternOffsetTest < ExpectTest
+  def test_byte_offsets_captures_and_buffer_consumption
+    cases = [
+      ["abENDtail", /END/, 2, 3, []],
+      ["中文终点尾", /(终)(点)/, 6, 6, ["终".b, "点".b]],
+      ["😀中😀尾", /(😀)(x)?/, 0, 4, ["😀".b, nil]],
+      ["😀中END尾", /END/, 7, 3, []],
+      ["a\0b", /(\0)/n, 1, 1, ["\0".b]],
+      ["\xFF\x00\xFE".b, /(\xFE)/n, 2, 1, ["\xFE".b]],
+      ["中文尾", /(?=尾)/, 6, 0, []],
+      ["😀", /$/u, 4, 0, []]
+    ]
+    session, = pipe_session
+    cases.each do |text, regexp, offset, length, captures|
+      # 扫描只读调用者输入；省去正则副本后也不能改变编码标记或冻结字符串。
+      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
+      assert_equal bytes.byteslice(offset, length), result.match
+      assert_equal bytes.byteslice((offset + length)..), result.after
+      assert_equal captures, result.captures
+      assert_equal result.after, session.buffer
+    end
+  end
+
+  def test_incomplete_utf8_defers_matching_and_eof_still_rejects_it
+    pattern = Expect::Pattern.new(value: /中(?=😀)/)
+    bytes = "前中😀".b
+    (1..3).each do |missing|
+      partial = bytes.byteslice(0, bytes.bytesize - missing)
+      assert_nil pattern.locate(partial)
+      assert_raises(EncodingError) { pattern.locate(partial, final: true) }
+    end
+    assert_equal [3, 3, []], pattern.locate(bytes)
+  end
+end

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

@@ -234,6 +234,43 @@ class RelayRecoveryTest < ExpectTest
     end
   end
 
+  def test_split_literal_and_short_write_failures_preserve_delivery_and_callback_order
+    [1, 2, 3].product([1, 2, 3], [0, 2]).each do |split, step, failure_offset|
+      source, writer = pipe_session
+      fast = StringIO.new
+      received = "".b
+      failed = false
+      slow = Object.new
+      slow.define_singleton_method(:write) do |data|
+        if !failed && received.bytesize == failure_offset
+          failed = true
+          raise IOError, "injected partial delivery"
+        end
+        count = [step, data.bytesize].min
+        count = [count, failure_offset - received.bytesize].min unless failed
+        received << data.byteslice(0, count)
+        count
+      end
+      callbacks = []
+      source.listeners = [fast, slow]
+      source.on_sequence("STOP") do
+        callbacks << [fast.string.dup, received.dup]
+        false
+      end
+      source.buffer = "head#{"STOP".byteslice(0, split)}"
+      writer.write("#{"STOP".byteslice(split..)}tail")
+      assert_raises(IOError) { bounded { Expect.interconnect(source, timeout: 1) } }
+      assert_empty callbacks
+      assert source.pending_output?
+      assert_same(source, bounded { Expect.interconnect(source, timeout: 1) })
+      assert_equal [%w[head head]], callbacks
+      assert_equal "tail", source.buffer
+      assert_equal "head", fast.string
+      assert_equal "head", received
+      refute source.pending_output?
+    end
+  end
+
   def test_flush_failure_retries_flush_without_replaying_data
     source, = pipe_session
     output = StringIO.new

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