expect-pty 0.5.3 → 0.6.1

data/test/matching_test.rb

@@ -1,211 +0,0 @@
-# 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_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)
-    assert_equal 1, session.expect(/\x00(abc)/n, timeout: 1)
-    assert_equal "\xff".b, session.before
-    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"
-    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

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

data/test/ownership_sequence_test.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-require "minitest/mock"
-
-class OwnershipSequenceTest < ExpectTest
-  SEEDS = [20_260_927, 1, 42].freeze
-
-  def test_failed_initialization_then_failed_cleanup_preserves_ownership_and_primary_error
-    SEEDS.each do |seed|
-      [true, false].each do |own|
-        reader, writer = IO.pipe
-        @ios.push(reader, writer)
-        attempts = []
-        failure = seed.odd? ? Interrupt.new : SystemExit.new(17)
-        original = writer.method(:close)
-        Expect::SessionResources.stub(:new, ->(*, **) { raise failure }) do
-          reader.stub(:close, lambda {
-            attempts << :reader
-            raise IOError, "injected close failure"
-          }) do
-            writer.stub(:close, lambda {
-              attempts << :writer
-              original.call
-            }) do
-              error = assert_raises(failure.class) { Expect.open(reader, writer: writer, own: own) }
-              assert_same failure, error, "seed=#{seed} own=#{own}"
-            end
-          end
-        end
-        assert_equal(own ? %i[reader writer] : [], attempts, "seed=#{seed} own=#{own}")
-        assert_equal own, writer.closed?
-        refute reader.closed?
-      end
-    end
-  end
-
-  def test_short_write_eintr_timeout_and_listener_replacement_keep_per_target_progress
-    SEEDS.each do |seed|
-      source, = pipe_session
-      sink, target_writer = IO.pipe
-      @ios.push(sink, target_writer)
-      target, = pipe_session(writer: target_writer, write_timeout: 0.01)
-      first = StringIO.new
-      replacement = StringIO.new
-      payload = Random.new(seed).bytes(9)
-      source.listeners = [first, target]
-      source.buffer = payload
-      accepted = 2
-      attempts = 0
-      now = 0.0
-      original = target_writer.method(:write_nonblock)
-      Expect.stub(:monotonic, -> { now }) do
-        target_writer.stub(:write_nonblock, lambda { |bytes, **options|
-          attempts += 1
-          case attempts
-          when 1 then original.call(bytes.byteslice(0, accepted), **options)
-          when 2 then raise Errno::EINTR
-          else
-            now = 0.02
-            :wait_writable
-          end
-        }) do
-          error = assert_raises(Expect::WriteTimeout) { bounded { Expect.interconnect(source, timeout: 1) } }
-          assert_equal accepted, error.bytes_written, "seed=#{seed} attempts=#{attempts}"
-        end
-      end
-      prefix = bounded { sink.read(accepted) }
-      assert_equal payload.byteslice(0, accepted), prefix, "seed=#{seed} confirmed=#{accepted}"
-      assert_equal payload, first.string.b, "seed=#{seed} first target"
-      assert_empty source.buffer
-      assert source.pending_output?
-      source.listeners = [replacement]
-      source.buffer = "new"
-      Expect.interconnect(source, timeout: 0)
-      suffix = bounded { sink.read(payload.bytesize - accepted) }
-      assert_equal payload, prefix + suffix, "seed=#{seed} resumed target"
-      assert_equal payload, first.string.b, "seed=#{seed} first target replay"
-      assert_equal "new", replacement.string, "seed=#{seed} replacement target"
-      refute source.pending_output?
-      assert_empty source.buffer
-    end
-  end
-
-  def test_escape_delivery_nested_match_and_resume_account_for_all_source_bytes_once
-    SEEDS.each do |seed|
-      source, producer = pipe_session
-      prefix = "prefix-#{seed}\0".b
-      payload = "#{prefix}!consumetail".b
-      log = StringIO.new
-      sink = StringIO.new
-      source.log_to(log)
-      source.listeners = [sink]
-      calls = 0
-      source.on_sequence("!") do
-        calls += 1
-        assert_equal prefix, sink.string.b, "seed=#{seed} prefix not delivered"
-        assert_equal "consume", source.expect_result("consume", timeout: 0).match
-        false
-      end
-      producer.write(payload)
-      assert_same(source, bounded { Expect.interconnect(source, timeout: 1) })
-      assert_equal "tail", source.buffer
-      assert_equal 1, calls
-      assert_equal payload.bytesize, prefix.bytesize + 1 + "consume".bytesize + source.buffer.bytesize
-      Expect.interconnect(source, timeout: 0)
-      assert_equal "#{prefix}tail", sink.string.b, "seed=#{seed} delivered bytes"
-      assert_equal payload, log.string.b, "seed=#{seed} received log replay"
-      assert_equal 1, calls
-      refute source.pending_output?
-      assert_empty source.buffer
-    end
-  end
-
-  def test_refused_recursion_then_sequential_relay_preserves_bytes_and_releases_ownership
-    SEEDS.each do |seed|
-      source, = pipe_session
-      payload = Random.new(seed).bytes(7)
-      sink = StringIO.new
-      original = sink.method(:write)
-      errors = []
-      sink.define_singleton_method(:write) do |bytes|
-        count = original.call(bytes)
-        begin
-          Expect.interconnect(source, timeout: 0)
-        rescue Expect::ReentrancyError => error
-          errors << error
-        end
-        count
-      end
-      source.listeners = [sink]
-      2.times do |index|
-        source.buffer = payload
-        Expect.interconnect(source, timeout: 0)
-        assert_equal payload * (index + 1), sink.string.b, "seed=#{seed} iteration=#{index}"
-        assert_equal index + 1, errors.size
-        assert_empty source.buffer
-        refute source.pending_output?
-      end
-    end
-  end
-
-  def test_eof_soft_close_hard_close_and_repeated_status_queries
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    session = Expect.open(reader, own: true)
-    @sessions << session
-    script = <<~RUBY
-      Signal.trap("HUP", "IGNORE")
-      Signal.trap("TERM", "IGNORE")
-      STDOUT.sync = true
-      print "tail"
-      STDOUT.reopen(File::NULL, "w")
-      sleep 60
-    RUBY
-    pid = Process.spawn(RbConfig.ruby, "--disable-gems", "-e", script, in: File::NULL, out: writer, err: File::NULL)
-    session.instance_variable_get(:@resources).pid = pid
-    writer.close
-    result = session.expect_result(:eof, timeout: 2)
-    assert result.eof?
-    assert_equal "tail", result.before
-    assert session.alive?
-    refute session.closed?
-    signals = []
-    original = Process.method(:kill)
-    Process.stub(:kill, lambda { |signal, child_pid|
-      signals << signal
-      original.call(signal, child_pid)
-    }) do
-      assert_nil session.soft_close(timeout: 0, term_timeout: 0)
-    end
-    assert_equal ["TERM"], signals
-    assert session.closed?
-    assert session.alive?
-    status = bounded { session.hard_close(timeout: 0) }
-    assert_equal Signal.list.fetch("KILL"), status.termsig
-    3.times { assert_same status, session.process_status }
-    assert_nil session.pid
-    assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-  ensure
-    session&.hard_close(timeout: 0)
-  end
-
-  def test_expired_deadline_dispatches_known_eof_in_order_without_consuming_new_text
-    SEEDS.each do |seed|
-      ended = Array.new(2) { pipe_session.first }
-      ended.each(&:close)
-      ended.shuffle!(random: Random.new(seed))
-      live, producer = pipe_session
-      live.buffer = "buffered"
-      producer.write("unread")
-      seen = []
-      Expect.stub(:monotonic, 1.0) do
-        result = Expect.expect_result(from: [*ended, live], deadline: 1.0) do
-          on("buffered") { flunk "seed=#{seed} consumed text after deadline" }
-          eof do |session|
-            seen << session
-            Expect.continue(reset_timeout: seed.odd?)
-          end
-        end
-        assert result.timeout?
-      end
-      assert_equal ended, seen, "seed=#{seed} EOF order"
-      assert_equal "buffered", live.buffer
-      assert_equal "unread", live.to_io.read_nonblock(6)
-    end
-  end
-end

data/test/pattern_offset_test.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class PatternOffsetTest < ExpectTest
-  def test_byte_offsets_captures_and_buffer_consumption
-    cases = [
-      ["abENDtail", /END/, 2, 3, []],
-      ["中文终点尾", /(终)(点)/, 6, 6, ["终".b, "点".b]],
-      ["😀中😀尾", /(😀)(x)?/, 0, 4, ["😀".b, nil]],
-      ["😀中END尾", /END/, 7, 3, []],
-      ["a\0b", /(\0)/n, 1, 1, ["\0".b]],
-      ["\xFF\x00\xFE".b, /(\xFE)/n, 2, 1, ["\xFE".b]],
-      ["中文尾", /(?=尾)/, 6, 0, []],
-      ["😀", /$/u, 4, 0, []]
-    ]
-    session, = pipe_session
-    cases.each do |text, regexp, offset, length, captures|
-      # 扫描只读调用者输入；省去正则副本后也不能改变编码标记或冻结字符串。
-      bytes = text.b.freeze
-      assert_equal [offset, length, captures], Expect::Pattern.new(value: regexp).locate(bytes)
-      assert_equal Encoding::BINARY, bytes.encoding
-      session.buffer = bytes
-      result = session.expect_result(regexp, timeout: 0)
-      assert_equal bytes.byteslice(0, offset), result.before
-      assert_equal bytes.byteslice(offset, length), result.match
-      assert_equal bytes.byteslice((offset + length)..), result.after
-      assert_equal captures, result.captures
-      assert_equal result.after, session.buffer
-    end
-  end
-
-  def test_incomplete_utf8_defers_matching_and_eof_still_rejects_it
-    pattern = Expect::Pattern.new(value: /中(?=😀)/)
-    bytes = "前中😀".b
-    (1..3).each do |missing|
-      partial = bytes.byteslice(0, bytes.bytesize - missing)
-      assert_nil pattern.locate(partial)
-      assert_raises(EncodingError) { pattern.locate(partial, final: true) }
-    end
-    assert_equal [3, 3, []], pattern.locate(bytes)
-  end
-end