expect-pty 0.2.0 → 0.3.0

data/test/io_test.rb

@@ -49,6 +49,26 @@ class IOTest < ExpectTest
     assert_equal "\ncba\n", chunks.join
   end
 
+  def test_new_log_files_are_private_without_changing_existing_permissions
+    session, = pipe_session
+    Dir.mktmpdir do |directory|
+      previous_umask = File.umask(0o022)
+      begin
+        %w[a w].each do |mode|
+          path = File.join(directory, "session-#{mode}.log")
+          session.log_to(path, mode: mode)
+          assert_equal 0o600, File.stat(path).mode & 0o777
+          session.log_output = nil
+          File.chmod(0o640, path)
+          session.log_to(path, mode: mode)
+          assert_equal 0o640, File.stat(path).mode & 0o777
+        end
+      ensure
+        File.umask(previous_umask)
+      end
+    end
+  end
+
   def test_group_and_stdout_logging_can_be_controlled_separately
     session, writer = pipe_session
     listener = StringIO.new
@@ -85,6 +105,25 @@ class IOTest < ExpectTest
     assert_match(/received "more"/, diagnostics)
   end
 
+  def test_quiet_mode_does_not_format_byte_content_for_diagnostics
+    session, peer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(session, peer)
+    connection = Expect.open(session, debug_level: 0)
+    @sessions << connection
+    inspected = 0
+    probe = TracePoint.new(:c_call) do |event|
+      inspected += 1 if event.defined_class == String && event.method_id == :inspect
+    end
+
+    probe.enable do
+      connection.write("hello")
+      peer.write("reply")
+      connection.expect("reply", timeout: 1)
+    end
+
+    assert_equal 0, inspected
+  end
+
   def test_send_slow_collects_replies_even_when_logging_disabled
     session = child("loop { char = STDIN.read(1); break unless char; print char.upcase }", raw_pty: true)
     session.log_listeners = false
@@ -121,6 +160,69 @@ class IOTest < ExpectTest
     assert_empty Expect.readable_sessions(first, second)
   end
 
+  def test_readiness_retries_an_interrupted_select
+    session, writer = pipe_session
+    writer.write("ready")
+    original = IO.method(:select)
+    interrupted = true
+    select = lambda do |*arguments|
+      if interrupted
+        interrupted = false
+        raise Errno::EINTR
+      end
+      original.call(*arguments)
+    end
+
+    IO.stub(:select, select) do
+      assert_equal [session], Expect.readable_sessions(session, timeout: 1)
+    end
+  end
+
+  def test_write_retries_an_interrupted_nonblocking_write
+    reader, writer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(reader, writer)
+    session = Expect.open(reader)
+    @sessions << session
+    original = reader.method(:write_nonblock)
+    interrupted = true
+    write = lambda do |*arguments, **options|
+      if interrupted
+        interrupted = false
+        raise Errno::EINTR
+      end
+      original.call(*arguments, **options)
+    end
+
+    reader.stub(:write_nonblock, write) do
+      assert_equal 5, session.write("hello")
+    end
+    assert_equal "hello", writer.read(5)
+  end
+
+  def test_write_retries_an_interrupted_writable_wait
+    reader, writer = Socket.pair(:UNIX, :STREAM, 0)
+    @ios.push(reader, writer)
+    session = Expect.open(reader, write_timeout: 1)
+    @sessions << session
+    original = reader.method(:write_nonblock)
+    waiting = true
+    write = lambda do |*arguments, **options|
+      if waiting
+        waiting = false
+        :wait_writable
+      else
+        original.call(*arguments, **options)
+      end
+    end
+
+    reader.stub(:write_nonblock, write) do
+      IO.stub(:select, ->(*) { raise Errno::EINTR }) do
+        assert_equal 5, session.write("hello")
+      end
+    end
+    assert_equal "hello", writer.read(5)
+  end
+
   def test_readiness_waits_for_data_and_does_not_consume_data
     first, = pipe_session
     second, writer = pipe_session

data/test/matching_test.rb

@@ -126,6 +126,19 @@ class MatchingTest < ExpectTest
     assert_equal 1, session.expect("结束", timeout: 1)
   end
 
+  def test_utf8_regexp_waits_for_incomplete_trailing_character_before_matching
+    session, writer = pipe_session
+    session.buffer = "ready\xE4".b
+
+    assert_nil session.expect(/ready\z/u, timeout: 0)
+    assert_nil session.expect(/ready/u, timeout: 0)
+    assert_equal "ready\xE4".b, session.buffer
+
+    writer.write("\xB8\xAD".b)
+    assert_equal 1, session.expect(/ready中\z/u, timeout: 1)
+    assert_equal "ready中".b, session.match
+  end
+
   def test_binary_nul_and_invalid_utf8
     session, writer = pipe_session
     writer.write("\xff\x00abc\xfe".b)
@@ -134,6 +147,26 @@ class MatchingTest < ExpectTest
     assert_equal ["abc"], session.captures
   end
 
+  def test_utf8_regexp_rejects_impossible_partial_characters
+    session, = pipe_session
+    ["\xE0\x80", "\xED\xA0", "\xF0\x80", "\xF4\x90"].each do |bytes|
+      session.buffer = bytes.b
+      assert_raises(EncodingError) { session.expect(/ready/u, timeout: 0) }
+      assert_equal bytes.b, session.buffer
+    end
+  end
+
+  def test_utf8_regexp_accepts_valid_partial_characters
+    session, = pipe_session
+    ["¢", "中", "😀", "\u{10FFFF}"].each do |character|
+      1.upto(character.bytesize - 1) do |length|
+        session.buffer = character.b.byteslice(0, length)
+        assert_nil session.expect(/./u, timeout: 0)
+        assert_equal character.b.byteslice(0, length), session.buffer
+      end
+    end
+  end
+
   def test_native_regexp_anchors_and_flags
     session, = pipe_session
     session.buffer = "a\nb\nc"

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,72 @@ 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
+                output, = capture_io { release.run }
+                assert_includes output, "SHA256 verified"
+              end
+            end
+          end
+        end
+      end
+      assert published
+    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")

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)