expect-pty 0.2.0

data/test/io_test.rb

@@ -0,0 +1,184 @@
+# 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_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_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_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_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

@@ -0,0 +1,45 @@
+# 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/matching_test.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class MatchingTest < ExpectTest
+  def test_literal_regexp_number_and_result_tuple
+    session, = pipe_session
+    session.buffer = "before a.c between abc:42 after"
+    assert_equal 2, session.expect("absent", "a.c", timeout: 0)
+    assert_equal "before ", session.before
+    assert_equal "a.c", session.match
+    result = session.expect_result(/abc:(\d+)/, timeout: 0)
+    assert_equal [1, nil, "abc:42", " between ", " after", session, ["42"]], result.to_a
+    assert_equal ["42"], session.captures
+    assert result.matched?
+    refute result.timeout?
+    refute result.eof?
+  end
+
+  def test_regexp_callback_captures_lexical_arguments
+    session, = pipe_session
+    session.buffer = "prefix xyz42 suffix"
+    observed = []
+    argument = :value
+    number = session.expect(timeout: 0) do
+      on(/xyz(\d+)/) { |object| observed << [object.captures, argument] }
+    end
+    assert_equal 1, number
+    assert_equal [[["42"], :value]], observed
+  end
+
+  def test_native_regexp_and_literal_event_names
+    session, = pipe_session
+    session.buffer = "timeout eof -word a.c end99"
+    assert_equal 1, session.expect("timeout", timeout: 0)
+    assert_equal 1, session.expect("eof", timeout: 0)
+    assert_equal 1, session.expect("-word", timeout: 0)
+    assert_equal 1, session.expect("a.c", timeout: 0)
+    assert_equal 1, session.expect(/end\d+/, timeout: 0)
+  end
+
+  def test_patterns_have_priority_over_their_position_in_buffer
+    session, = pipe_session
+    session.buffer = "second first"
+    assert_equal 1, session.expect("first", "second", timeout: 0)
+    assert_equal "second ", session.before
+  end
+
+  def test_regexp_uses_actual_offset_with_lookbehind
+    session, = pipe_session
+    session.buffer = "same prefix same end"
+    session.expect(/(?<=prefix )same/, timeout: 0)
+    assert_equal "same prefix ", session.before
+    assert_equal " end", session.after
+  end
+
+  def test_unmatched_capture_and_zero_width_pattern
+    session, = pipe_session
+    session.buffer = "b"
+    assert_equal 1, session.expect(/(a)?(?=b)/, timeout: 0)
+    assert_equal [nil], session.captures
+    assert_equal "", session.match
+    assert_equal "b", session.buffer
+  end
+
+  def test_capture_list_clears_for_literal_and_timeout
+    session, = pipe_session
+    session.buffer = "a1 b"
+    session.expect(/a(\d)/, timeout: 0)
+    session.expect("b", timeout: 0)
+    assert_empty session.captures
+    assert_nil session.expect(/absent/, timeout: 0)
+    assert_nil session.match
+    assert_nil session.after
+    assert_empty session.captures
+  end
+
+  def test_buffer_retained_on_timeout_and_manually_replaceable
+    session, writer = pipe_session
+    writer.write("some string")
+    assert_nil session.expect("other", timeout: 0.03)
+    assert_equal :timeout, session.error
+    assert_equal "some string", session.before
+    assert_equal 1, session.expect("some", timeout: 0)
+    assert_equal " string", session.buffer
+    session.buffer = "new"
+    assert_equal "new", session.clear_buffer
+    assert_empty session.buffer
+  end
+
+  def test_preserve_buffer_and_buffer_limit
+    session, = pipe_session
+    session.preserve_buffer = true
+    session.buffer = "prefix token tail"
+    2.times { assert_equal 1, session.expect("token", timeout: 0) }
+    assert_equal "prefix token tail", session.buffer
+    session.buffer_limit = 4
+    assert_equal "tail", session.buffer
+    session.buffer_limit = nil
+    session.buffer = "123456"
+    assert_equal "123456", session.buffer
+  end
+
+  def test_split_patterns_across_reads
+    session, writer = pipe_session
+    background do
+      writer.write("pass")
+      sleep 0.03
+      writer.write("word: ")
+    end
+    assert_equal 1, session.expect(/password: /, timeout: 1)
+  end
+
+  def test_utf8_regexp_split_character_and_byte_offsets
+    session, writer = pipe_session
+    bytes = "前缀密码：结束".b
+    background do
+      bytes.each_byte do |byte|
+        writer.write(byte.chr)
+        sleep 0.001
+      end
+    end
+    assert_equal 1, session.expect(/(密码)：/, timeout: 1)
+    assert_equal "前缀".b, session.before
+    assert_equal ["密码".b], session.captures
+    assert_equal 1, session.expect("结束", timeout: 1)
+  end
+
+  def test_binary_nul_and_invalid_utf8
+    session, writer = pipe_session
+    writer.write("\xff\x00abc\xfe".b)
+    assert_equal 1, session.expect(/\x00(abc)/n, timeout: 1)
+    assert_equal "\xff".b, session.before
+    assert_equal ["abc"], session.captures
+  end
+
+  def test_native_regexp_anchors_and_flags
+    session, = pipe_session
+    session.buffer = "a\nb\nc"
+    session.preserve_buffer = true
+    assert_nil session.expect("^b$", timeout: 0)
+    assert_nil session.expect(/\Ab\z/, timeout: 0)
+    assert_equal 1, session.expect(/^b$/, timeout: 0)
+    assert_equal 1, session.expect(/a.b/m, timeout: 0)
+    assert_nil session.expect(/a.b/, timeout: 0)
+  end
+
+  def test_eof_callback_consumes_remaining_buffer
+    session, writer = pipe_session
+    writer.write("last bytes")
+    writer.close
+    seen = nil
+    result = session.expect_result(timeout: 1) { eof { |object| seen = object.before } }
+    assert_nil result.number
+    assert result.eof?
+    assert_equal "last bytes", seen
+    assert_empty session.buffer
+  end
+
+  def test_read_without_patterns_and_match_before_eof
+    session, writer = pipe_session
+    writer.write("END")
+    writer.close
+    assert_equal 1, session.expect("END", timeout: nil)
+    assert session.expect_result(timeout: nil).eof?
+  end
+
+  def test_argument_validation_does_not_read_io
+    session, = pipe_session
+    assert_raises(ArgumentError) { session.expect("x", timeout: -1) }
+    assert_raises(ArgumentError) { session.expect("x", timeout: Float::INFINITY) }
+    assert_raises(ArgumentError) { session.expect(["a", 42], timeout: 0) }
+    assert_raises(ArgumentError) { session.expect("-i", [], timeout: 0) }
+    assert_raises(ArgumentError) { session.expect(Object.new, timeout: 0) }
+    assert_raises(ArgumentError) { Expect.expect("x", timeout: 0) }
+    assert_raises(ArgumentError) { session.buffer_limit = -1 }
+  end
+end

data/test/multi_session_test.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class MultiSessionTest < ExpectTest
+  def test_multi_session_pattern_groups_and_global_numbering
+    first, first_writer = pipe_session
+    second, second_writer = pipe_session
+    first_writer.write("irrelevant")
+    second_writer.write("second:42")
+    result = Expect.expect_result(timeout: 1) do
+      on("first", from: first)
+      on(/second:(\d+)/, from: second)
+    end
+    assert_equal 2, result.number
+    assert_same second, result.session
+    assert_equal ["42"], result.captures
+    assert_equal "irrelevant", first.buffer
+  end
+
+  def test_shared_patterns_across_sessions
+    first, = pipe_session
+    second, writer = pipe_session
+    writer.write("ready")
+    assert_equal 1, Expect.expect("ready", from: [first, second], timeout: 1)
+    assert_equal "ready", second.match
+  end
+
+  def test_eof_continue_removes_closed_session_and_waits_for_remaining
+    first, first_writer = pipe_session
+    second, second_writer = pipe_session
+    first_writer.close
+    ended = []
+    result = Expect.expect_result(timeout: 1) do
+      eof(from: first) do |connection|
+        ended << connection
+        second_writer.write("done")
+        Expect.continue(reset_timeout: false)
+      end
+      on("done", from: second)
+    end
+    assert_equal [first], ended
+    assert_equal 2, result.number
+    assert_same second, result.session
+  end
+
+  def test_all_eof_continuation_returns_without_waiting_forever
+    first, writer = pipe_session
+    writer.close
+    result = bounded { first.expect_result(timeout: nil) { eof { Expect.continue } } }
+    assert result.eof?
+  end
+
+  def test_same_session_in_multiple_groups_is_read_once
+    session, writer = pipe_session
+    writer.write("right")
+    other, = pipe_session
+    result = Expect.expect_result(timeout: 1) do
+      on("wrong", from: session)
+      on("missing", from: other)
+      on("right", from: session)
+    end
+    assert_equal 3, result.number
+    assert_equal "right", result.match
+  end
+end