expect-pty 0.2.0 → 0.3.1

data/test/relay_recovery_test.rb

@@ -0,0 +1,414 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class RelayRecoveryTest < ExpectTest
+  def sink_session(**)
+    reader, peer = IO.pipe
+    sink, writer = IO.pipe
+    @ios.push(reader, peer, sink, writer)
+    session = Expect.open(reader, writer: writer, **)
+    @sessions << session
+    [session, sink, peer]
+  end
+
+  def fill(writer)
+    total = 0
+    loop do
+      count = writer.write_nonblock("x" * 4096, exception: false)
+      return total if count == :wait_writable
+
+      total += count
+    end
+  end
+
+  def drain(reader)
+    data = "".b
+    loop do
+      chunk = reader.read_nonblock(65_536, exception: false)
+      return data if chunk == :wait_readable || chunk.nil?
+
+      data << chunk
+    end
+  end
+
+  def test_outer_deadline_bounds_raw_io_and_expect_listeners
+    [false, true].each do |wrapped|
+      source, = pipe_session
+      target, = sink_session
+      fill(target.writer)
+      source.listeners = [wrapped ? target : target.writer]
+      source.buffer = "request"
+      started = Expect.monotonic
+      assert_nil bounded(0.5) { Expect.interconnect(source, target, timeout: 0.02) }
+      assert_operator Expect.monotonic - started, :<, 0.3
+    end
+  end
+
+  def test_partial_timeout_and_retry_deliver_exactly_once_to_each_listener
+    source, source_writer = pipe_session
+    target, sink = sink_session(write_timeout: 0.02)
+    first = StringIO.new
+    source.listeners = [first, target]
+    payload = (0..255).to_a.pack("C*") * 2048
+    source.buffer = payload
+    assert_raises(Expect::WriteTimeout) { bounded { Expect.interconnect(source, timeout: 1) } }
+    received = drain(sink)
+    assert_operator received.bytesize, :>, 0
+    assert_operator received.bytesize, :<, payload.bytesize
+    target.write_timeout = 2
+    receiver = background do
+      loop { received << sink.readpartial(65_536) }
+    rescue EOFError
+      received
+    end
+    source_writer.close
+    assert_same(source, bounded { Expect.interconnect(source, timeout: 2) })
+    target.writer.close
+    assert receiver.join(2), "receiver did not finish"
+    assert_equal payload.bytesize, receiver.value.bytesize
+    assert payload == receiver.value, "resumed pipe output differs from the original bytes"
+    assert_equal payload.bytesize, first.string.bytesize
+    assert payload == first.string.b, "first listener output differs from the original bytes"
+  end
+
+  def test_short_custom_writes_preserve_suffix
+    source, = pipe_session
+    received = "".b
+    target = Object.new
+    target.define_singleton_method(:write) do |data|
+      count = [2, data.bytesize].min
+      received << data.byteslice(0, count)
+      count
+    end
+    source.listeners = [target]
+    source.buffer = "abcdef"
+    Expect.interconnect(source, timeout: 0.02)
+    assert_equal "abcdef", received
+  end
+
+  def test_failed_second_listener_does_not_replay_first_listener
+    source, = pipe_session
+    first = StringIO.new
+    second = StringIO.new
+    failing = true
+    original = second.method(:write)
+    second.define_singleton_method(:write) do |data|
+      raise IOError, "listener failed" if failing
+
+      original.call(data)
+    end
+    source.listeners = [first, second]
+    source.buffer = "payload"
+    assert_raises(IOError) { Expect.interconnect(source, timeout: 0.02) }
+    failing = false
+    Expect.interconnect(source, timeout: 0.02)
+    assert_equal "payload", first.string
+    assert_equal "payload", second.string
+  end
+
+  def test_repeated_interact_with_raw_input_keeps_read_ahead
+    session, sink = sink_session
+    input, keyboard = IO.pipe
+    @ios.push(input, keyboard)
+    keyboard.write("one!two!")
+    first = session.interact(input: input, output: StringIO.new, escape: "!", timeout: 0.05)
+    second = session.interact(input: input, output: StringIO.new, escape: "!", timeout: 0.05)
+    assert_same first, second
+    assert_equal "onetwo", drain(sink)
+    refute input.closed?
+  end
+
+  def test_write_retries_read_eintr_during_backpressure
+    session, sink, peer = sink_session(write_timeout: 1)
+    fill(session.writer)
+    peer.write("reply")
+    original = session.to_io.method(:read_nonblock)
+    interrupted = false
+    session.to_io.define_singleton_method(:read_nonblock) do |*args, **kwargs|
+      unless interrupted
+        interrupted = true
+        raise Errno::EINTR
+      end
+      original.call(*args, **kwargs)
+    end
+    session.log_to { drain(sink) }
+    assert_equal(5, bounded { session.write("hello") })
+    assert interrupted
+    assert_equal "reply", session.buffer
+    assert_equal "hello", drain(sink)
+  end
+
+  def test_write_timeout_reports_accepted_bytes
+    session, sink = sink_session(write_timeout: 0.02)
+    error = assert_raises(Expect::WriteTimeout) { session.write("x" * 524_288) }
+    received = drain(sink)
+    assert_operator received.bytesize, :>, 0
+    assert_equal received.bytesize, error.bytes_written
+  end
+
+  def test_nested_output_timeout_preserves_the_callers_write_progress
+    %i[listeners log_output].each do |destination|
+      session, sink, peer = sink_session(write_timeout: 1)
+      target, = sink_session(write_timeout: 0)
+      fill(target.writer)
+      session.public_send(:"#{destination}=", destination == :listeners ? [target] : target)
+      peer.write("reply")
+
+      error = assert_raises(Expect::WriteTimeout) { bounded { session.write("x" * 1_048_576) } }
+      received = drain(sink)
+      assert_operator received.bytesize, :>, 0
+      assert_equal received.bytesize, error.bytes_written
+      assert_instance_of Expect::WriteTimeout, error.cause
+      assert_equal 0, error.cause.bytes_written
+      assert_equal "reply", session.buffer
+    end
+  end
+
+  def test_truncated_utf8_at_eof_raises_without_losing_bytes
+    session, writer = pipe_session
+    writer.write("\xe4".b)
+    writer.close
+    assert_raises(EncodingError) { session.expect(/中/u, timeout: 1) }
+    assert_equal "\xe4".b, session.buffer
+    assert_equal 1, session.expect("\xe4".b, timeout: 0)
+  end
+
+  def test_blocked_target_does_not_starve_another_source
+    slow, = pipe_session
+    fast, writer = pipe_session
+    target, = sink_session
+    fill(target.writer)
+    slow.listeners = [target]
+    slow.buffer = "blocked"
+    output = StringIO.new
+    fast.listeners = [output]
+    writer.write("ready")
+    assert_nil bounded(0.5) { Expect.interconnect(slow, fast, timeout: 0.02) }
+    assert_equal "ready", output.string
+    assert slow.pending_output?
+  end
+
+  def test_outer_timeout_keeps_output_for_original_targets
+    source, = pipe_session
+    target, sink = sink_session
+    fill(target.writer)
+    source.listeners = [target.writer]
+    source.buffer = "request"
+    Expect.interconnect(source, timeout: 0.01)
+    assert source.pending_output?
+    assert_empty source.buffer
+    drain(sink)
+    replacement = StringIO.new
+    source.listeners = [replacement]
+    source.buffer = "new"
+    Expect.interconnect(source, timeout: 0.02)
+    refute source.pending_output?
+    assert_equal "request", drain(sink)
+    assert_equal "new", replacement.string
+  end
+
+  def test_every_short_write_failure_position_resumes_without_replay
+    0.upto(5) do |failure_offset|
+      source, = pipe_session
+      first = StringIO.new
+      received = "".b
+      failed = false
+      target = Object.new
+      target.define_singleton_method(:write) do |data|
+        if !failed && received.bytesize == failure_offset
+          failed = true
+          raise IOError, "interrupted delivery"
+        end
+        received << data.byteslice(0, 1)
+        1
+      end
+      source.listeners = [first, target]
+      source.buffer = "abcdef"
+      assert_raises(IOError) { Expect.interconnect(source, timeout: 1) }
+      assert source.pending_output?
+      Expect.interconnect(source, timeout: 0.01)
+      assert_equal "abcdef", received
+      assert_equal "abcdef", first.string
+      refute source.pending_output?
+    end
+  end
+
+  def test_flush_failure_retries_flush_without_replaying_data
+    source, = pipe_session
+    output = StringIO.new
+    failed = false
+    output.define_singleton_method(:flush) do
+      return if failed
+
+      failed = true
+      raise IOError, "flush failed"
+    end
+    source.listeners = [output]
+    source.buffer = "once"
+    assert_raises(IOError) { Expect.interconnect(source, timeout: 1) }
+    Expect.interconnect(source, timeout: 0.01)
+    assert_equal "once", output.string
+    refute source.pending_output?
+  end
+
+  def test_invalid_write_count_raises_and_can_recover
+    [0, nil, -1, 7, "6"].each do |invalid|
+      source, = pipe_session
+      output = StringIO.new
+      source.listeners = [output]
+      source.buffer = "abcdef"
+      output.stub(:write, invalid) do
+        assert_raises(IOError) { bounded { Expect.interconnect(source, timeout: 1) } }
+      end
+      Expect.interconnect(source, timeout: 0.01)
+      assert_equal "abcdef", output.string
+    end
+  end
+
+  def test_escape_callback_waits_for_prefix_delivery_across_timeout
+    source, = pipe_session
+    target, sink = sink_session
+    fill(target.writer)
+    source.listeners = [target]
+    called = 0
+    source.on_sequence(/END\z/) do
+      called += 1
+      false
+    end
+    source.buffer = "prefixEND"
+    assert_nil Expect.interconnect(source, timeout: 0.01)
+    assert_equal 0, called
+    source.buffer = "tail"
+    drain(sink)
+    assert_same source, Expect.interconnect(source, timeout: 0.1)
+    assert_equal 1, called
+    assert_equal "prefix", drain(sink)
+    assert_equal "tail", source.buffer
+  end
+
+  def test_matching_window_does_not_truncate_undelivered_relay_input
+    source, writer = pipe_session(buffer_limit: 2)
+    target, sink = sink_session
+    fill(target.writer)
+    source.listeners = [target]
+    source.on_sequence("!")
+    writer.write("prefix!tail")
+    Expect.interconnect(source, timeout: 0.01)
+    assert_equal "tail", source.buffer
+    drain(sink)
+    assert_same source, Expect.interconnect(source, timeout: 0.1)
+    assert_equal "prefix", drain(sink)
+    assert_equal "tail", source.buffer
+  end
+
+  def test_unlisted_target_output_is_drained_without_losing_bytes
+    source, writer = pipe_session
+    target = child('puts "ready"; data = STDIN.read(131072); print "reply" if data.bytesize == 131072',
+                   raw_pty: true, write_timeout: 1)
+    source.listeners = [target]
+    source.buffer = "x" * 131_072
+    writer.close
+    assert_same(source, bounded { Expect.interconnect(source, timeout: 2) })
+    refute source.pending_output?
+    assert_empty source.buffer
+    assert_equal 1, target.expect("ready", timeout: 1)
+    assert_equal 1, target.expect("reply", timeout: 1)
+  end
+
+  def test_eof_validates_truncated_utf8_in_escape_regex
+    source, writer = pipe_session
+    source.on_sequence(/中/u)
+    writer.write("\xe4".b)
+    writer.close
+    assert_raises(EncodingError) { Expect.interconnect(source, timeout: 1) }
+  end
+
+  def test_instance_regexp_timeout_propagates_and_keeps_buffer
+    source, = pipe_session
+    source.buffer = "#{"a" * 30}!"
+    regexp = Regexp.new('\\A(a+)+\\1\\z', timeout: 0.01)
+    global_timeout = Regexp.timeout
+    assert_raises(Regexp::TimeoutError) { bounded { source.expect(regexp, timeout: 0) } }
+    assert_equal "#{"a" * 30}!", source.buffer
+    assert Regexp.timeout == global_timeout, "matching must not change the process regexp timeout"
+    assert_equal 0.01, regexp.timeout
+  end
+
+  def test_closed_cached_input_wrapper_can_be_reopened_without_closing_raw_io
+    session, sink = sink_session
+    input, keyboard = IO.pipe
+    @ios.push(input, keyboard)
+    keyboard.write("one!")
+    source = session.interact(input: input, output: StringIO.new, escape: "!", timeout: 0.1)
+    source.close
+    keyboard.write("two!")
+    resumed = session.interact(input: input, output: StringIO.new, escape: "!", timeout: 0.1)
+    refute_same source, resumed
+    assert_equal "onetwo", drain(sink)
+    resumed.graceful_close = true
+    bounded(0.5) { session.close }
+    assert resumed.closed?
+    refute input.closed?
+  end
+
+  def test_repeated_read_interruptions_do_not_extend_write_timeout
+    session, = sink_session(write_timeout: 0.02)
+    fill(session.writer)
+    reads = 0
+    session.to_io.stub(:read_nonblock, lambda { |*|
+      reads += 1
+      raise Errno::EINTR
+    }) do
+      IO.stub(:select, ->(*) { [[session.to_io], [], []] }) do
+        error = assert_raises(Expect::WriteTimeout) { bounded(0.5) { session.write("request") } }
+        assert_equal 0, error.bytes_written
+      end
+    end
+    assert_operator reads, :>, 1
+  end
+
+  def test_zero_timeout_retains_a_blocked_escape_prefix_for_retry
+    source, = pipe_session
+    target, sink = sink_session
+    fill(target.writer)
+    source.on_sequence("STOP")
+    source.listeners = [target]
+    source.buffer = "ST"
+    assert_nil bounded(0.5) { Expect.interconnect(source, timeout: 0) }
+    assert source.pending_output?
+    drain(sink)
+    Expect.interconnect(source, timeout: 0.01)
+    assert_equal "ST", drain(sink)
+    refute source.pending_output?
+  end
+
+  def test_short_log_writes_keep_all_bytes
+    source, = pipe_session
+    output = StringIO.new
+    original = output.method(:write)
+    output.define_singleton_method(:write) { |data| original.call(data.byteslice(0, 1)) }
+    source.log_to(output)
+    source.write_log("complete")
+    assert_equal "complete", output.string
+  end
+
+  def test_interrupted_custom_output_is_retried_without_waiting_for_new_input
+    source, = pipe_session
+    output = StringIO.new
+    interrupted = false
+    original = output.method(:write)
+    output.define_singleton_method(:write) do |data|
+      unless interrupted
+        interrupted = true
+        raise Errno::EINTR
+      end
+      original.call(data)
+    end
+    source.listeners = [output]
+    source.on_sequence("!")
+    source.buffer = "ready!"
+    assert_same source, bounded(0.5) { Expect.interconnect(source, timeout: 0.05) }
+    assert_equal "ready", output.string
+  end
+end

data/test/release_test.rb

@@ -25,7 +25,7 @@ class ReleaseTest < Minitest::Test
           capture_io { release.run }
         end
       end
-      directory = Dir.glob(File.join("pkg", "release", Expect::VERSION, "candidate-*")).fetch(0)
+      directory = Dir.glob(File.join("tmp", "release", Expect::VERSION, "candidate-*")).fetch(0)
       checksum = File.read(File.join(directory, "SHA256SUMS"))
       assert_equal "#{Digest::SHA256.file(artifact).hexdigest}  #{File.basename(artifact)}\n", checksum
       assert_equal "- Release fixture.\n", File.read(File.join(directory, "release-notes.md"))
@@ -34,6 +34,92 @@ class ReleaseTest < Minitest::Test
     end
   end
 
+  def test_rubygems_only_publishes_the_verified_copy_without_github
+    with_package do |_release, artifact|
+      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)
+        elsif published
+          Struct.new(:code, :body).new("200", JSON.generate("sha" => checksum, "yanked" => false))
+        else
+          Struct.new(:code, :body).new("404", "")
+        end
+      end
+      push = lambda do |*arguments|
+        candidate = arguments.fetch(2)
+        assert_equal ["gem", "push", candidate, "--host", "https://rubygems.org"], arguments
+        assert_match %r{/tmp/release/#{Regexp.escape(Expect::VERSION)}/candidate-[^/]+/}, candidate
+        assert_equal bytes, File.binread(candidate)
+        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
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_ci_publish_requires_an_api_key_before_pushing
+    release = Release.new(rubygems_only: true)
+    release.stub(:registry_version, nil) do
+      release.stub(:system, ->(*) { flunk "pushed without a CI API key" }) do
+        [nil, ""].each do |api_key|
+          with_environment("GITHUB_ACTIONS" => "true", "GEM_HOST_API_KEY" => api_key) do
+            error = assert_raises(RuntimeError) { release.send(:publish_rubygems) }
+            assert_includes error.message, "RUBYGEMS_API_KEY"
+          end
+        end
+      end
+    end
+  end
+
+  def test_rubygems_only_rejects_uncommitted_source_before_publishing
+    with_package do |_release, artifact|
+      release = Release.new(artifact: artifact, rubygems_only: true)
+      release.stub(:capture, " M payload.rb") do
+        release.stub(:get, ->(*) { flunk "uncommitted source contacted RubyGems" }) do
+          assert_match "Commit all source changes", assert_raises(RuntimeError) { release.run }.message
+        end
+      end
+    end
+  end
+
+  def test_rubygems_only_rechecks_source_after_verification
+    with_package do |_release, artifact|
+      release = Release.new(artifact: artifact, rubygems_only: true)
+      statuses = ["", " M payload.rb"]
+      capture = ->(*arguments) { arguments.include?("rev-parse") ? "verified" : statuses.shift }
+      release.stub(:capture, capture) do
+        release.stub(:get, ->(*) { flunk "changed source contacted RubyGems" }) do
+          capture_io do
+            assert_match "Source changed", assert_raises(RuntimeError) { release.run }.message
+          end
+        end
+      end
+    end
+  end
+
   def test_rejects_a_package_from_different_source
     with_package do |release, _artifact|
       File.write("payload.rb", "puts :changed\n")
@@ -128,6 +214,17 @@ class ReleaseTest < Minitest::Test
 
   private
 
+  # 发布测试显式控制凭据环境，避免本机登录状态或 CI 标记影响用例结果。
+  def with_environment(values)
+    previous = values.to_h { |name, _value| [name, ENV.fetch(name, nil)] }
+    begin
+      values.each { |name, value| ENV[name] = value }
+      yield
+    ensure
+      previous.each { |name, value| ENV[name] = value }
+    end
+  end
+
   def with_package
     Dir.mktmpdir("expect-release-test-") do |directory|
       Dir.chdir(directory) do

data/test/support/script_probe.rb

@@ -10,6 +10,7 @@ require_relative "../../lib/expect/pty"
 module ScriptProbe
   PROMPT = "EXPECT_SCRIPT_PROMPT> "
   FIXTURES = File.expand_path("../fixtures/ssh_scripts", __dir__)
+
   class Failure < StandardError; end
 
   def self.check(condition, message)

metadata

@@ -1,14 +1,102 @@
 --- !ruby/object:Gem::Specification
 name: expect-pty
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - expect-pty contributors
 bindir: bin
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
-dependencies: []
+date: 2026-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: forwardable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: io-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: io-wait
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: shellwords
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: stringio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Automate interactive programs with exact and regexp matching, Ruby blocks,
   multi-session waits, logging and terminal interaction.
 executables: []
@@ -34,13 +122,15 @@ files:
 - expect-pty.gemspec
 - lib/expect.rb
 - lib/expect/configuration.rb
-- lib/expect/engine.rb
-- lib/expect/interconnect.rb
+- lib/expect/interaction.rb
+- lib/expect/matcher.rb
 - lib/expect/pattern.rb
 - lib/expect/pattern_list.rb
 - lib/expect/pty.rb
-- lib/expect/resources.rb
+- lib/expect/relay.rb
+- lib/expect/relay_writer.rb
 - lib/expect/result.rb
+- lib/expect/session_resources.rb
 - lib/expect/version.rb
 - script/ci
 - script/release.rb
@@ -61,6 +151,7 @@ files:
 - test/matching_test.rb
 - test/multi_session_test.rb
 - test/process_test.rb
+- test/relay_recovery_test.rb
 - test/release_test.rb
 - test/ruby_api_test.rb
 - test/script_logging_test.rb
@@ -91,7 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.12
 specification_version: 4
 summary: Ruby PTY automation with the Expect.pm interaction model
 test_files: []