expect-pty 0.5.3 → 0.6.1

data/test/io_test.rb

@@ -1,321 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class IOTest < ExpectTest
-  def test_socket_pair_send_and_expect
-    client, server = Socket.pair(:UNIX, :STREAM, 0)
-    @ios.push(client, server)
-    session = Expect.open(client)
-    @sessions << session
-    background do
-      server.write("prompt>")
-      server.write(server.gets.upcase)
-    end
-    assert_equal 1, session.expect("prompt>", timeout: 1)
-    assert_equal 6, session.write("hello\n")
-    assert_equal 1, session.expect("HELLO\n", timeout: 1)
-  end
-
-  def test_log_file_append_truncate_disable_and_manual_output
-    session, writer = pipe_session
-    Dir.mktmpdir do |dir|
-      path = File.join(dir, "session.log")
-      File.write(path, "old")
-      log = session.log_to(path)
-      writer.write("reply")
-      session.expect("reply", timeout: 1)
-      session.write_log(" annotation")
-      session.log_output = nil
-      assert log.closed?
-      assert_equal "oldreply annotation", File.binread(path)
-      session.log_to(path, mode: "w")
-      writer.write("new")
-      session.expect("new", timeout: 1)
-      session.log_output = nil
-      assert_equal "new", File.binread(path)
-      writer.write("unlogged")
-      session.expect("unlogged", timeout: 1)
-      assert_equal "new", File.binread(path)
-    end
-  end
-
-  def test_logging_matches_upstream_received_data_only
-    session = child("puts STDIN.gets.reverse", raw_pty: true)
-    chunks = []
-    session.log_to(->(data) { chunks << data })
-    session.write("abc\n")
-    session.expect("cba", timeout: 2)
-    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
-    session.listeners = [listener]
-    writer.write("one")
-    session.expect("one", timeout: 1)
-    assert_equal "one", listener.string
-    session.log_listeners = false
-    session.log_stdout = true
-    output, = capture_io do
-      writer.write("two")
-      session.expect("two", timeout: 1)
-    end
-    assert_equal "two", output
-    assert_equal "one", listener.string
-    session.listeners = []
-    assert_empty session.listeners
-  end
-
-  def test_debug_and_internal_output
-    session, writer = pipe_session
-    session.debug_level = 1
-    _, diagnostics = capture_io do
-      writer.write("ready")
-      session.expect("ready", timeout: 1)
-    end
-    assert_match(/matched pattern 1/, diagnostics)
-    refute_match(/received/, diagnostics)
-    session.debug_level = 2
-    _, diagnostics = capture_io do
-      writer.write("more")
-      session.expect("more", timeout: 1)
-    end
-    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
-    start = Expect.monotonic
-    assert_equal 3, session.send_slow("abc", delay: 0.02)
-    assert_operator Expect.monotonic - start, :>=, 0.06
-    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)
-    payload = (0..255).to_a.pack("C*") * 1024
-    bounded do
-      assert_equal payload.bytesize, session.write(payload)
-      assert_equal 1, session.expect(payload, timeout: 3)
-    end
-    assert_equal payload, session.match
-  end
-
-  def test_write_timeout_on_backpressure
-    session = child('puts "ready"; sleep 30', raw_pty: true, write_timeout: 0.05)
-    session.expect("ready", timeout: 2)
-    assert_raises(Expect::WriteTimeout) { bounded { session.write("x" * 1_000_000) } }
-  end
-
-  def test_readiness_returns_readable_sessions
-    first, = pipe_session
-    second, writer = pipe_session
-    assert_empty Expect.readable_sessions(first, second)
-    writer.write("data")
-    assert_equal [second], Expect.readable_sessions(first, second)
-    second.expect("data", timeout: 1)
-    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
-    background do
-      sleep 0.03
-      writer.write("ready")
-    end
-    assert_equal([second], bounded { Expect.readable_sessions(first, second, timeout: 1) })
-    assert_equal 1, second.expect("ready", timeout: 0)
-    assert_empty Expect.readable_sessions(first, second, timeout: 0)
-  end
-
-  def test_readiness_accepts_keyword_and_unlimited_timeout
-    session, writer = pipe_session
-    assert_empty Expect.readable_sessions(session, timeout: 0.01)
-    background do
-      sleep 0.03
-      writer.write("ready")
-    end
-    assert_equal([session], bounded { Expect.readable_sessions(session, timeout: nil) })
-    assert_equal [session], Expect.readable_sessions(session, timeout: 0)
-    assert_raises(ArgumentError) { Expect.readable_sessions(session, timeout: -1) }
-    assert_raises(ArgumentError) { Expect.readable_sessions(0, session, timeout: 1) }
-    assert_raises(ArgumentError) { Expect.readable_sessions("invalid") }
-  end
-
-  def test_readiness_excludes_closed_sessions
-    first, = pipe_session
-    second, writer = pipe_session
-    first.close
-    writer.write("ready")
-    assert_equal [second], Expect.readable_sessions(first, second, timeout: 0)
-    assert_empty Expect.readable_sessions
-  end
-
-  def test_read_io_error_is_reported
-    Tempfile.create("expect-write-only") do |file|
-      File.open(file.path, "w") do |writer|
-        session = Expect.open(writer)
-        @sessions << session
-        result = session.expect_result("x", timeout: 1)
-        assert_instance_of IOError, result.error
-      end
-    end
-  end
-
-  def test_log_io_failure_does_not_masquerade_as_child_eof
-    session = child('puts "ready"; STDIN.gets; puts "response"; sleep 30', raw_pty: true)
-    assert_equal 1, session.expect("ready\n", timeout: 2)
-    session.log_to(->(_) { raise Errno::EIO, "log failed" })
-    session.write("continue\n")
-    result = session.expect_result("response", timeout: 2)
-    assert_instance_of Errno::EIO, result.error
-    refute result.eof?
-    refute session.eof?
-    assert session.alive?
-    assert_includes result.before, "response\n"
-    session.log_output = nil
-    assert_equal 1, session.expect("response", timeout: 0)
-  end
-end

data/test/kibitz_test.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-require_relative "support/kibitz_probe"
-
-class KibitzTest < ExpectTest
-  def test_two_terminals_share_shell_echo_signals_and_logged_output
-    Dir.mktmpdir { |directory| assert KibitzProbe.shared_shell(directory)[:passed] }
-  end
-
-  def test_noproc_split_custom_escape_does_not_leak_to_peer
-    Dir.mktmpdir { |directory| assert KibitzProbe.direct(directory, ending: :host)[:passed] }
-  end
-
-  def test_guest_escape_ends_both_sides_and_restores_terminals
-    Dir.mktmpdir { |directory| assert KibitzProbe.direct(directory, ending: :guest)[:passed] }
-  end
-
-  def test_noescape_forwards_control_character_as_data
-    Dir.mktmpdir { |directory| assert KibitzProbe.noescape(directory)[:passed] }
-  end
-
-  def test_shared_process_failure_is_reported
-    Dir.mktmpdir { |directory| assert KibitzProbe.process_failure(directory)[:passed] }
-  end
-
-  def test_relay_timeout_restores_terminals_and_closes_peer
-    Dir.mktmpdir { |directory| assert KibitzProbe.relay_timeout(directory)[:passed] }
-  end
-
-  def test_missing_partner_times_out_and_removes_socket
-    session = Expect.new(log_stdout: false)
-    @sessions << session
-    saved = InteractProbe.configuration(session)
-    session.spawn(RbConfig.ruby, KibitzProbe::EXAMPLE, "--timeout", "0.2")
-    result = session.expect_result(%r{--join (/tmp/expect-kibitz-[^\r\n ]+/peer\.sock)}, timeout: 3)
-    assert result.matched?
-    path = result.captures.first
-    assert session.expect_result(:eof, timeout: 3).eof?
-    assert_includes session.before, "timed out waiting for partner"
-    assert_equal 1, session.wait(timeout: 1).exitstatus
-    assert_equal saved, InteractProbe.configuration(session)
-    refute File.exist?(File.dirname(path))
-  end
-end

data/test/lifecycle_contract_test.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class LifecycleContractTest < ExpectTest
-  def test_external_reaping_releases_pid_without_fabricating_process_status
-    session = child('puts "ready"; exit 7', raw_pty: true)
-    assert_equal 1, session.expect("ready", timeout: 2)
-    pid = session.pid
-    assert_equal(7, bounded { Process.waitpid2(pid).last.exitstatus })
-    refute session.alive?
-    assert_nil session.pid
-    assert_nil session.process_status
-    assert_nil session.wait(timeout: 0)
-    Process.stub(:kill, ->(*) { flunk "must not signal an externally reaped PID" }) do
-      2.times { session.close }
-    end
-    assert session.closed?
-  end
-
-  def test_external_reader_close_does_not_take_ownership_of_the_writer
-    reader, producer = IO.pipe
-    consumer, writer = IO.pipe
-    @ios.push(reader, producer, consumer, writer)
-    session = Expect.open(reader, writer: writer)
-    @sessions << session
-    session.buffer = "tail"
-    reader.close
-    assert session.closed?
-    assert session.eof?
-    refute session.alive?
-    assert_raises(IOError) { session.write("blocked") }
-    2.times { session.close }
-    refute writer.closed?
-    assert_equal "tail", session.buffer
-    writer.write("borrowed")
-    assert_equal "borrowed", consumer.read(8)
-  end
-
-  def test_failed_handle_close_can_be_retried_without_losing_other_owned_handles
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    session = Expect.open(reader, writer: writer, own: true)
-    @sessions << session
-    failure = IOError.new("close failed")
-    reader.stub(:close, -> { raise failure }) do
-      assert_same failure, assert_raises(IOError) { session.close }
-      assert writer.closed?
-      refute reader.closed?
-      assert session.closed?
-    end
-    session.close
-    assert reader.closed?
-    assert_nil session.close
-  end
-
-  def test_timeout_and_eof_remain_events_and_write_errors_remain_io_errors
-    session, writer = pipe_session
-    timeout = session.expect_result("missing", timeout: 0)
-    assert timeout.timeout?
-    assert_equal :timeout, timeout.error
-    writer.close
-    eof = session.expect_result(:eof, timeout: 1)
-    assert eof.eof?
-    assert_equal :eof, eof.error
-    failure = Expect::WriteTimeout.new(bytes_written: 3)
-    assert_kind_of IOError, failure
-    assert_equal 3, failure.bytes_written
-    assert_operator Expect::SpawnError, :<, StandardError
-  end
-end

data/test/literal_scan_test.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class LiteralScanTest < ExpectTest
-  def test_new_bytes_can_complete_a_previously_missing_literal
-    session, writer = pipe_session
-    list = Expect::PatternList.new([session], ["password:", "word:"])
-    matcher = Expect::Matcher.new(list, nil)
-    session.buffer = "prefix pass"
-    assert_nil matcher.__send__(:find_match)
-    writer.write("word:")
-    session.__send__(:read_available)
-    result = matcher.__send__(:find_match)
-    assert_equal 1, result[1].number
-    assert_equal [7, 9, []], result[2]
-  end
-
-  def test_later_text_for_an_earlier_pattern_keeps_declaration_priority
-    session, writer = pipe_session
-    list = Expect::PatternList.new([session], %w[preferred ready])
-    matcher = Expect::Matcher.new(list, nil)
-    session.buffer = "ready"
-    assert_equal 2, matcher.__send__(:find_match)[1].number
-    writer.write(" preferred")
-    session.__send__(:read_available)
-    assert_equal 1, matcher.__send__(:find_match)[1].number
-  end
-
-  def test_destructive_buffer_changes_invalidate_old_misses
-    session, writer = pipe_session
-    list = Expect::PatternList.new([session], ["start", "token", /END/])
-    matcher = Expect::Matcher.new(list, nil)
-    session.buffer = "x" * 100
-    assert_nil matcher.__send__(:find_match)
-    session.buffer = "start"
-    assert_equal 1, matcher.__send__(:find_match)[1].number
-    session.clear_buffer
-    assert_nil matcher.__send__(:find_match)
-    writer.write("token")
-    session.__send__(:read_available)
-    assert_equal 2, matcher.__send__(:find_match)[1].number
-    session.expect("token", timeout: 0)
-    session.buffer_limit = 8
-    writer.write("xxxxstart")
-    session.__send__(:read_available)
-    assert_equal [3, 5, []], matcher.__send__(:find_match)[2]
-    session.clear_buffer
-    session.__send__(:restore_relay_buffer, "token")
-    assert_equal 2, matcher.__send__(:find_match)[1].number
-  end
-
-  def test_repeated_scans_equal_a_fresh_matcher_across_operation_sequences
-    session, writer = pipe_session
-    patterns = ["abc", "bc", "\0\xff".b, /END/n]
-    list = Expect::PatternList.new([session], patterns)
-    matcher = Expect::Matcher.new(list, nil)
-    random = Random.new(40_033)
-    chunks = ["a", "b", "c", "x", "END", "\0", "\xff".b]
-    150.times do
-      case random.rand(6)
-      when 0
-        session.buffer = chunks.sample(random: random) * random.rand(1..4)
-      when 1
-        session.clear_buffer
-      when 2
-        session.buffer_limit = [nil, 2, 5, 12].sample(random: random)
-      when 3
-        session.__send__(:restore_relay_buffer, chunks.sample(random: random).b)
-      when 4
-        session.expect("x", timeout: 0)
-      else
-        writer.write(chunks.sample(random: random))
-        session.__send__(:read_available)
-      end
-      expected = Expect::Matcher.new(list, nil).__send__(:find_match)
-      actual = matcher.__send__(:find_match)
-      assert_equal signature(expected), signature(actual), "buffer=#{session.buffer.inspect}"
-    end
-  end
-
-  def test_a_dynamically_registered_pattern_is_scanned_from_the_start
-    session, = pipe_session
-    session.buffer = "prefix ready"
-    list = Expect::PatternList.new([session], ["missing"])
-    matcher = Expect::Matcher.new(list, nil)
-    assert_nil matcher.__send__(:find_match)
-    list.on("prefix")
-    assert_equal [0, 6, []], matcher.__send__(:find_match)[2]
-  end
-
-  private
-
-  def signature(result)
-    result ? [result[0], result[1].number, result[2]] : []
-  end
-end