expect-pty 0.5.2 → 0.5.3

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

data/test/release_test.rb

@@ -10,6 +10,40 @@ class ReleaseTest < Minitest::Test
     assert_equal "- New API.", Release.release_notes(changelog, "0.2.0")
   end
 
+  def test_dry_run_writes_identical_utf8_notes_in_c_and_utf8_locales
+    notes = "- 修复初始化中断，保留原异常。\n"
+    with_package do |_release, artifact|
+      script = locale_script
+      File.write("CHANGELOG.md", "## #{Expect::VERSION}\n\n#{notes}", encoding: "UTF-8")
+      rebuild_package
+      %w[US-ASCII UTF-8].each do |encoding|
+        env = release_environment.merge("LC_ALL" => (encoding == "US-ASCII" ? "C" : "en_US.UTF-8"), "LANG" => "C")
+        output, error, status = Open3.capture3(env, RbConfig.ruby, "-E#{encoding}", script,
+                                               "--dry-run", "--artifact", artifact, binmode: true)
+        assert status.success?, "#{encoding}: #{output} #{error}"
+        assert_includes output, "Dry run complete"
+        files = Dir.glob("tmp/release/#{Expect::VERSION}/candidate-*/release-notes.md")
+        refute_empty files
+        files.each { |file| assert_equal notes.b, File.binread(file) }
+      end
+    end
+  end
+
+  def test_dry_run_rejects_invalid_utf8_without_rewriting_the_changelog
+    with_package do |_release, artifact|
+      script = locale_script
+      bytes = "## #{Expect::VERSION}\n- invalid \xff\n".b
+      File.binwrite("CHANGELOG.md", bytes)
+      rebuild_package
+      _output, error, status = Open3.capture3(release_environment.merge("LC_ALL" => "C", "LANG" => "C"),
+                                              RbConfig.ruby, "-EUS-ASCII", script, "--dry-run", "--artifact", artifact)
+      refute status.success?
+      assert_includes error, "Invalid UTF-8 in CHANGELOG.md"
+      assert_equal bytes, File.binread("CHANGELOG.md")
+      assert_empty Dir.glob("tmp/release/#{Expect::VERSION}/candidate-*")
+    end
+  end
+
   def test_rejects_unreleased_missing_empty_or_invalid_versions
     ["## Unreleased\n- Pending.\n## 0.2.0\n- Ready.", "## 0.1.1\n- Old.", "## 0.2.0\n"].each do |changelog|
       assert_raises(RuntimeError) { Release.release_notes(changelog, "0.2.0") }
@@ -261,6 +295,19 @@ class ReleaseTest < Minitest::Test
 
   private
 
+  # CLI 按自身路径定位项目根目录；复制入口和版本文件，避免误读开发仓库的 CHANGELOG。
+  def locale_script
+    FileUtils.mkdir_p(["script", "lib/expect"])
+    FileUtils.cp(File.expand_path("../script/release.rb", __dir__), "script/release.rb")
+    FileUtils.cp(File.expand_path("../lib/expect/version.rb", __dir__), "lib/expect/version.rb")
+    File.expand_path("script/release.rb")
+  end
+
+  def release_environment
+    names = ENV.keys.grep(/\ABUNDLE/) + %w[RUBYOPT RUBYLIB RUBYGEMS_GEMDEPS]
+    names.to_h { |name| [name, nil] }
+  end
+
   def git(*)
     output, error, status = Open3.capture3("git", *)
     assert status.success?, error

data/test/write_contract_test.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "minitest/mock"
+
+class WriteContractTest < ExpectTest
+  def test_invalid_write_counts_fail_on_the_first_attempt
+    [0, -1, nil, "3", 4].each do |invalid|
+      session, = writable_session
+      attempts = 0
+      session.writer.stub(:write_nonblock, lambda { |*, **|
+        attempts += 1
+        invalid
+      }) do
+        error = assert_raises(IOError) { bounded(0.2) { session.write("abc") } }
+        refute_kind_of Expect::WriteTimeout, error
+        assert_match(/accepted bytes/, error.message)
+        assert_equal 1, attempts
+      end
+    end
+  end
+
+  def test_count_is_checked_against_the_attempted_chunk_not_the_total_input
+    session, = writable_session
+    session.writer.stub(:write_nonblock, lambda { |chunk, **|
+      assert_equal Expect::READ_SIZE, chunk.bytesize
+      chunk.bytesize + 1
+    }) do
+      assert_raises(IOError) { session.write("x" * (Expect::READ_SIZE + 1)) }
+    end
+  end
+
+  def test_successful_short_writes_can_outlive_the_backpressure_deadline
+    session, sink = writable_session(write_timeout: 0.01)
+    now = 0.0
+    original = session.writer.method(:write_nonblock)
+    Expect.stub(:monotonic, -> { now }) do
+      session.writer.stub(:write_nonblock, lambda { |chunk, **options|
+        count = original.call(chunk.byteslice(0, 1), **options)
+        now += 0.02
+        count
+      }) do
+        assert_equal 3, session.write("abc")
+      end
+    end
+    assert_in_delta 0.06, now
+    assert_equal("abc", bounded { sink.read(3) })
+  end
+
+  def test_empty_input_never_attempts_a_write
+    session, = writable_session(write_timeout: 0)
+    session.writer.stub(:write_nonblock, ->(*, **) { flunk "empty input reached writer" }) do
+      assert_equal 0, session.write
+      assert_equal 0, session.write("")
+    end
+  end
+
+  def test_valid_short_writes_and_eintr_preserve_every_byte
+    session, sink = writable_session
+    original = session.writer.method(:write_nonblock)
+    attempts = 0
+    session.writer.stub(:write_nonblock, lambda { |chunk, **options|
+      attempts += 1
+      raise Errno::EINTR if attempts == 2
+
+      original.call(chunk.byteslice(0, 1), **options)
+    }) do
+      assert_equal(4, bounded { session.write("a\0\xffb".b) })
+    end
+    assert_equal 5, attempts
+    assert_equal("a\0\xffb".b, bounded { sink.read(4) })
+  end
+
+  def test_backpressure_reports_only_confirmed_progress
+    session, sink = writable_session(write_timeout: 0.01)
+    original = session.writer.method(:write_nonblock)
+    now = 0.0
+    attempts = 0
+    Expect.stub(:monotonic, -> { now }) do
+      session.writer.stub(:write_nonblock, lambda { |chunk, **options|
+        attempts += 1
+        next :wait_writable if attempts > 1
+
+        now = 0.02
+        original.call(chunk.byteslice(0, 1), **options)
+      }) do
+        error = assert_raises(Expect::WriteTimeout) { bounded { session.write("abc") } }
+        assert_equal 1, error.bytes_written
+      end
+    end
+    assert_equal 2, attempts
+    assert_equal("a", bounded { sink.read(1) })
+  end
+
+  private
+
+  def writable_session(**)
+    reader, producer = IO.pipe
+    sink, writer = IO.pipe
+    @ios.push(reader, producer, sink, writer)
+    session = Expect.open(reader, writer: writer, **)
+    @sessions << session
+    [session, sink]
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expect-pty
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - expect-pty contributors
@@ -158,6 +158,7 @@ files:
 - test/fixtures/ssh_scripts/03_delayed.sh
 - test/fixtures/ssh_scripts/04_failure.sh
 - test/fixtures/ssh_scripts/05_recovery.sh
+- test/initialization_failure_test.rb
 - test/integration/README.md
 - test/integration/ssh_scripts.rb
 - test/interact_test.rb
@@ -168,10 +169,13 @@ files:
 - test/literal_scan_test.rb
 - test/matching_test.rb
 - test/multi_session_test.rb
+- test/ownership_sequence_test.rb
 - test/pattern_offset_test.rb
+- test/process_interruption_test.rb
 - test/process_test.rb
 - test/redactor_test.rb
 - test/relay_recovery_test.rb
+- test/relay_reentrancy_test.rb
 - test/release_test.rb
 - test/ruby_api_test.rb
 - test/scan_reuse_test.rb
@@ -182,6 +186,7 @@ files:
 - test/terminal_cleanup_test.rb
 - test/test_helper.rb
 - test/timeout_test.rb
+- test/write_contract_test.rb
 homepage: https://github.com/gatework/expect-ruby
 licenses:
 - MIT
@@ -204,7 +209,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: []