expect-pty 0.5.3 → 0.7.1

data/test/cleanup_test.rb

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class CleanupTest < ExpectTest
-  def test_failed_open_initialization_attempts_all_owned_handles_and_preserves_validation_error
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    reader.stub(:close, -> { raise IOError, "reader close failed" }) do
-      error = assert_raises(ArgumentError) { Expect.open(reader, writer: writer, own: true, unknown: true) }
-      assert_match(/unknown/, error.message)
-      assert writer.closed?
-    end
-  end
-
-  def test_failed_new_initialization_attempts_all_pty_handles_and_preserves_validation_error
-    master, slave = PTY.open
-    @ios.push(master, slave)
-    PTY.stub(:open, [master, slave]) do
-      master.stub(:close, -> { raise IOError, "master close failed" }) do
-        error = assert_raises(ArgumentError) { Expect.new(unknown: true) }
-        assert_match(/unknown/, error.message)
-        assert slave.closed?
-      end
-    end
-  end
-
-  def test_failed_open_closes_real_owned_handles_when_an_argument_is_not_io
-    [true, false].each do |invalid_reader|
-      reader, writer = IO.pipe
-      @ios.push(reader, writer)
-      invalid = Object.new
-      invalid.define_singleton_method(:close) { raise "invalid IO must not be closed" }
-      incoming = invalid_reader ? invalid : reader
-      outgoing = invalid_reader ? writer : invalid
-      assert_raises(ArgumentError) { Expect.open(incoming, writer: outgoing, own: true) }
-      assert(invalid_reader ? writer.closed? : reader.closed?)
-    end
-  end
-
-  def test_open_block_error_is_preserved_when_owned_cleanup_also_fails
-    [ArgumentError.new("block failed"), Interrupt.new("interrupted"), SystemExit.new(17)].each do |failure|
-      reader, writer = IO.pipe
-      @ios.push(reader, writer)
-      reader.stub(:close, -> { raise IOError, "reader close failed" }) do
-        error = assert_raises(failure.class) do
-          Expect.open(reader, writer: writer, own: true) { raise failure }
-        end
-        assert_same failure, error
-        assert writer.closed?
-      end
-    end
-  end
-
-  def test_open_block_break_still_reports_cleanup_failure
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    failure = IOError.new("reader close failed")
-    reader.stub(:close, -> { raise failure }) do
-      error = assert_raises(IOError) { Expect.open(reader, writer: writer, own: true) { break :done } }
-      assert_same failure, error
-      assert writer.closed?
-    end
-  end
-
-  def test_spawn_block_error_is_preserved_and_child_reaped_when_cleanup_also_fails
-    session = stubborn_child
-    failure = ArgumentError.new("block failed")
-    Expect.stub(:new, session) do
-      session.stub(:spawn, session) do
-        session.to_io.stub(:close, -> { raise IOError, "reader close failed" }) do
-          error = assert_raises(ArgumentError) { Expect.spawn("already started") { raise failure } }
-          assert_same failure, error
-          assert_nil session.pid
-        end
-      end
-    end
-  end
-
-  def test_graceful_close_preserves_logging_error_when_handle_cleanup_also_fails
-    session = stubborn_child
-    failure = ArgumentError.new("log failed")
-    session.log_output = ->(_) { raise failure }
-    session.to_io.stub(:wait_readable, true) do
-      session.to_io.stub(:read_nonblock, "last output") do
-        session.to_io.stub(:close, -> { raise IOError, "reader close failed" }) do
-          assert_same failure, assert_raises(ArgumentError) { session.close(graceful: true) }
-          assert_nil session.pid
-        end
-      end
-    end
-  end
-
-  def test_close_handles_attempts_every_owned_handle_and_preserves_first_error
-    reader, writer = IO.pipe
-    extra, peer = IO.pipe
-    @ios.push(reader, writer, extra, peer)
-    resources = Expect::SessionResources.new(reader, writer: writer, slave: extra, own: true)
-    failure = IOError.new("reader close failed")
-    reader.stub(:close, -> { raise failure }) do
-      assert_same failure, assert_raises(IOError) { resources.close_handles }
-      assert writer.closed?
-      assert extra.closed?
-    end
-    resources.close_handles
-    assert reader.closed?
-    resources.close_handles
-  end
-
-  def test_hard_close_finishes_wrappers_log_and_child_after_handle_failure
-    session = stubborn_child
-    pid = session.pid
-    first, = pipe_session
-    second, = pipe_session
-    session.instance_variable_set(:@interact_inputs, { first.to_io => first, second.to_io => second })
-    Dir.mktmpdir do |dir|
-      log = session.log_to(File.join(dir, "owned.log"))
-      failure = IOError.new("handle close failed")
-      session.to_io.stub(:close, -> { raise failure }) do
-        first.stub(:close, ->(**) { raise IOError, "wrapper close failed" }) do
-          error = assert_raises(IOError) { bounded { session.hard_close(timeout: 0.01) } }
-          assert_same failure, error
-          assert second.closed?
-          refute second.to_io.closed?, "borrowed wrapper IO must remain open"
-          assert log.closed?
-          assert_nil session.log_output
-          assert_nil session.pid
-          assert_equal Signal.list.fetch("KILL"), session.process_status.termsig
-          assert_raises(Errno::ECHILD) { Process.waitpid(pid, Process::WNOHANG) }
-        end
-      end
-    end
-  ensure
-    session&.hard_close(timeout: 0)
-  end
-
-  def test_owned_log_close_failure_is_visible_after_child_reaping_and_retryable
-    session = stubborn_child
-    Dir.mktmpdir do |dir|
-      log = session.log_to(File.join(dir, "owned.log"))
-      log.stub(:close, -> { raise IOError, "log close failed" }) do
-        assert_raises(IOError) { bounded { session.hard_close(timeout: 0.01) } }
-        assert_nil session.pid
-        assert_same log, session.log_output
-      end
-      status = session.hard_close(timeout: 0)
-      assert_same session.process_status, status
-      assert log.closed?
-      assert_nil session.log_output
-    end
-  ensure
-    session&.hard_close(timeout: 0)
-  end
-
-  def test_explicit_close_inside_rescue_does_not_hide_a_new_cleanup_error
-    session, = pipe_session(own: true)
-    failure = IOError.new("close failed inside caller rescue")
-    begin
-      raise ArgumentError, "already handled"
-    rescue ArgumentError
-      session.to_io.stub(:close, -> { raise failure }) do
-        assert_same failure, assert_raises(IOError) { session.hard_close(timeout: 0) }
-      end
-    end
-  end
-
-  def test_unexpected_process_error_is_not_replaced_by_cleanup_failure
-    session = stubborn_child
-    failure = RuntimeError.new("process wait failed")
-    session.to_io.stub(:close, -> { raise IOError, "close failed" }) do
-      session.stub(:wait, ->(**) { raise failure }) do
-        assert_same failure, assert_raises(RuntimeError) { session.hard_close(timeout: 0) }
-      end
-    end
-  ensure
-    session&.hard_close(timeout: 0)
-  end
-
-  def test_soft_close_handle_failure_still_sends_term_but_never_kill
-    session = stubborn_child
-    signals = []
-    original = Process.method(:kill)
-    Process.stub(:kill, lambda { |signal, pid|
-      signals << signal
-      original.call(signal, pid)
-    }) do
-      session.to_io.stub(:close, -> { raise Errno::EIO, "close failed" }) do
-        assert_raises(Errno::EIO) { bounded { session.soft_close(timeout: 0, term_timeout: 0) } }
-      end
-    end
-    assert_equal ["TERM"], signals
-    assert session.alive?
-    assert session.closed?
-  ensure
-    session&.hard_close(timeout: 0)
-  end
-
-  def test_finalizer_reaps_after_both_handle_and_log_close_fail
-    session = stubborn_child
-    pid = session.pid
-    resources = session.instance_variable_get(:@resources)
-    log_attempted = false
-    Dir.mktmpdir do |dir|
-      log = session.log_to(File.join(dir, "owned.log"))
-      session.to_io.stub(:close, -> { raise IOError, "handle failed" }) do
-        log.stub(:close, lambda {
-          log_attempted = true
-          raise Errno::EIO, "log failed"
-        }) do
-          bounded { resources.finalize }
-        end
-      end
-      assert log_attempted
-      assert_nil resources.pid
-      bounded do
-        loop do
-          Process.kill(0, pid)
-          sleep 0.005
-        rescue Errno::ESRCH
-          break
-        end
-      end
-    end
-  ensure
-    session&.hard_close(timeout: 0)
-  end
-
-  def test_non_owner_cleanup_never_signals_and_finalizer_leaves_handles_alone
-    session = stubborn_child
-    resources = session.instance_variable_get(:@resources)
-    Process.stub(:pid, -1) do
-      Process.stub(:kill, ->(*) { flunk "non-owner sent a signal" }) do
-        resources.finalize
-        refute session.to_io.closed?
-        assert_nil session.hard_close(timeout: 0)
-      end
-    end
-    assert session.alive?
-  ensure
-    session&.hard_close(timeout: 0)
-  end
-
-  private
-
-  def stubborn_child
-    session = child('Signal.trap("HUP", "IGNORE"); Signal.trap("TERM", "IGNORE"); puts "ready"; sleep 60',
-                    raw_pty: true)
-    assert_equal 1, session.expect("ready", timeout: 2)
-    session
-  end
-end

data/test/compare_upstream.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-# Optional differential check. The ordinary test suite has no Perl dependency.
-require "json"
-require "open3"
-require "rbconfig"
-require_relative "../lib/expect"
-
-upstream = ARGV.fetch(0) { abort "usage: ruby test/compare_upstream.rb /path/to/expect.pm" }
-perl = <<~'PERL'
-  use strict;
-  use warnings;
-  use Expect;
-  use JSON::PP;
-  my %results;
-  sub fresh {
-    my ($buffer) = @_;
-    my $e = Expect->new;
-    $e->log_stdout(0);
-    $e->set_accum($buffer);
-    return $e;
-  }
-  sub snapshot {
-    my ($e) = @_;
-    my $captures = $e->exp_matchlist;
-    return { number => $e->match_number, before => $e->before,
-             match => $e->match, after => $e->after, captures => $captures || [],
-             accum => $e->get_accum };
-  }
-  my $e = fresh('before a.c after');
-  $e->expect(0, 'absent', 'a.c');
-  $results{literal} = snapshot($e);
-  $e = fresh('prefix value=42 tail');
-  $e->expect(0, ['value=(\d+)']);
-  $results{regexp_array} = snapshot($e);
-  $e = fresh("first\nsecond\nthird");
-  $e->expect(0, '-re', '^second$');
-  $results{multiline} = snapshot($e);
-  $e = fresh('second first');
-  $e->expect(0, 'first', 'second');
-  $results{priority} = snapshot($e);
-  $e = fresh('before token tail');
-  $e->notransfer(1);
-  $e->expect(0, 'token');
-  $results{notransfer} = snapshot($e);
-  $e = fresh('discard tail');
-  $e->max_accum(4);
-  $e->expect(0, 'tail');
-  $results{max_accum} = snapshot($e);
-  $e = fresh('keep this');
-  $e->expect(0, 'missing');
-  $results{timeout} = { error => $e->exp_error, before => $e->before, accum => $e->get_accum };
-  $e = fresh('A B C End');
-  my @states;
-  $e->expect(1, ['[ABC]', sub { push @states, $_[0]->match; exp_continue }], 'End');
-  $results{continue} = { states => \@states, final => $e->match, number => $e->match_number };
-  $e = fresh('');
-  $e->raw_pty(1);
-  $e->spawn($^X, '-e', '$|=1; while (<STDIN>) { chomp; print scalar(reverse($_)), "\n" }');
-  $e->send("crate\n");
-  $e->expect(3, 'etarc');
-  $results{pty_dialogue} = { before => $e->before, match => $e->match, number => $e->match_number };
-  $e->hard_close;
-  pipe(my $reader, my $writer) or die $!;
-  $writer->autoflush(1);
-  my $input = Expect->exp_init($reader);
-  my $idle = fresh('');
-  print $writer 'beforeSTOP42;after';
-  $results{readiness} = [Expect::test_handles(1, $idle, $input)];
-  my @escapes;
-  $input->set_seq('STOP\d+;', sub { push @escapes, 'stopped'; return 0; });
-  Expect::interconnect($input);
-  $results{regexp_escape} = \@escapes;
-  close $writer;
-  print JSON::PP->new->canonical->encode(\%results);
-PERL
-
-output, errors, status = Open3.capture3("perl", "-I#{File.join(upstream, "lib")}", "-e", perl)
-abort "Perl fixture failed: #{errors}" unless status.success?
-expected = JSON.parse(output)
-actual = {}
-sessions = []
-fresh = lambda do |buffer|
-  session = Expect.new(log_stdout: false)
-  sessions << session
-  session.buffer = buffer
-  session
-end
-snapshot = lambda do |s|
-  { "number" => s.match_number, "before" => s.before, "match" => s.match,
-    "after" => s.after, "captures" => s.captures, "accum" => s.buffer }
-end
-
-begin
-  s = fresh.call("before a.c after")
-  s.expect("absent", "a.c", timeout: 0)
-  actual["literal"] = snapshot.call(s)
-  s = fresh.call("prefix value=42 tail")
-  s.expect(/value=(\d+)/, timeout: 0)
-  actual["regexp_array"] = snapshot.call(s)
-  s = fresh.call("first\nsecond\nthird")
-  s.expect(/^second$/, timeout: 0)
-  actual["multiline"] = snapshot.call(s)
-  s = fresh.call("second first")
-  s.expect("first", "second", timeout: 0)
-  actual["priority"] = snapshot.call(s)
-  s = fresh.call("before token tail")
-  s.preserve_buffer = true
-  s.expect("token", timeout: 0)
-  actual["notransfer"] = snapshot.call(s)
-  s = fresh.call("discard tail")
-  s.buffer_limit = 4
-  s.expect("tail", timeout: 0)
-  actual["max_accum"] = snapshot.call(s)
-  s = fresh.call("keep this")
-  s.expect("missing", timeout: 0)
-  actual["timeout"] =
-    { "error" => (s.error == :timeout ? "1:TIMEOUT" : s.error), "before" => s.before, "accum" => s.buffer }
-  s = fresh.call("A B C End")
-  states = []
-  s.expect(timeout: 1) do
-    on(/[ABC]/) do |object|
-      states << object.match
-      Expect.continue
-    end
-    on("End")
-  end
-  actual["continue"] = { "states" => states, "final" => s.match, "number" => s.match_number }
-  s = fresh.call("")
-  s.raw_pty = true
-  s.spawn(RbConfig.ruby, "--disable-gems", "-e",
-          "STDOUT.sync = true; while line = STDIN.gets; puts line.chomp.reverse; end")
-  s.write("crate\n")
-  s.expect("etarc", timeout: 3)
-  actual["pty_dialogue"] = { "before" => s.before, "match" => s.match, "number" => s.match_number }
-  reader, writer = IO.pipe
-  input = Expect.open(reader, own: true)
-  sessions << input
-  idle = fresh.call("")
-  writer.write("beforeSTOP42;after")
-  actual["readiness"] = Expect.readable_sessions(idle, input, timeout: 1).map { |session| [idle, input].index(session) }
-  escapes = []
-  input.on_sequence(/STOP\d+;/) do
-    escapes << "stopped"
-    false
-  end
-  Expect.interconnect(input, timeout: 1)
-  actual["regexp_escape"] = escapes
-  writer.close
-
-  failures = expected.keys.reject { |key| actual.fetch(key) == expected.fetch(key) }
-  failures.each { |key| warn "#{key}: Perl=#{expected[key].inspect} Ruby=#{actual[key].inspect}" }
-  abort "#{failures.length} upstream comparisons failed" unless failures.empty?
-  puts "#{expected.length} upstream comparisons passed (Expect.pm #{File.basename(upstream)})"
-ensure
-  sessions.reverse_each { |session| session.hard_close(timeout: 0.03) }
-end

data/test/configuration_test.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "test_helper"
-
-class ConfigurationTest < ExpectTest
-  def test_configuration_is_frozen_and_sessions_have_independent_settings
-    Expect.configure(timeout: 0.1) do |config|
-      config.buffer_limit = 4
-      config.log_stdout = false
-    end
-    first, = pipe_session
-    second, = pipe_session
-    first.timeout = 1
-    first.buffer_limit = nil
-    Expect.configure(timeout: 2)
-    third, = pipe_session
-
-    assert_equal 1, first.timeout
-    assert_equal 0.1, second.timeout
-    assert_equal 2, third.timeout
-    assert_equal 4, second.buffer_limit
-    assert_nil first.buffer_limit
-    assert_equal 2, Expect.configuration.timeout
-    assert_raises(FrozenError) { Expect.configuration.timeout = 10 }
-    Expect.configuration.to_h.clear
-    assert_equal 2, Expect.configuration.timeout
-  end
-
-  def test_configuration_errors_do_not_publish_partial_changes
-    previous = Expect.configuration
-    assert_raises(ArgumentError) { Expect.configure(unknown: true) }
-    assert_same previous, Expect.configuration
-    assert_raises(ArgumentError) do
-      Expect.configure do |config|
-        config.timeout = 5
-        config.debug_level = 4
-      end
-    end
-    assert_same previous, Expect.configuration
-    assert_raises(RuntimeError) { Expect.configure(timeout: 3) { raise "cancelled" } }
-    assert_same previous, Expect.configuration
-  end
-
-  def test_subclasses_inherit_configuration_and_can_override_it_independently
-    subclass = Class.new(Expect)
-    Expect.configure(timeout: 0.5)
-    assert_equal 0.5, subclass.configuration.timeout
-    subclass.configure(timeout: 1)
-    Expect.configure(timeout: 2)
-    reader, writer = IO.pipe
-    @ios.push(reader, writer)
-    subclass.open(reader) do |session|
-      assert_equal 1, session.timeout
-      assert_instance_of subclass, session
-    end
-    assert_equal 2, Expect.configuration.timeout
-  end
-
-  def test_concurrent_configure_updates_are_serialized
-    subclass = Class.new(Expect)
-    entered = Queue.new
-    second_started = Queue.new
-    release = Queue.new
-    first = Thread.new do
-      subclass.configure do |config|
-        entered << true
-        release.pop
-        config.timeout = 1
-      end
-    end
-    entered.pop
-    second = Thread.new do
-      second_started << true
-      subclass.configure(debug_level: 2)
-    end
-    second_started.pop
-    # 第一轮尚未发布时，第二轮不能从同一旧快照完成更新。
-    refute second.join(0.05), "concurrent configure published before the first update finished"
-    release << true
-    first.value
-    second.value
-    assert_equal 1, subclass.configuration.timeout
-    assert_equal 2, subclass.configuration.debug_level
-  ensure
-    release&.push(true)
-    first&.join
-    second&.join
-  end
-
-  def test_nested_configure_fails_without_publishing_partial_changes
-    subclass = Class.new(Expect)
-    previous = subclass.configuration
-    assert_raises(ThreadError) do
-      subclass.configure do |config|
-        config.timeout = 1
-        subclass.configure(debug_level: 2)
-      end
-    end
-    assert_same previous, subclass.configuration
-  end
-
-  def test_attribute_validation_preserves_the_current_value_and_buffer
-    session, = pipe_session(buffer_limit: 8, timeout: 1, write_timeout: 2, debug_level: 1)
-    session.buffer = "contents"
-    [0, -1, 1.5, "4"].each do |limit|
-      assert_raises(ArgumentError) { session.buffer_limit = limit }
-    end
-    assert_equal 8, session.buffer_limit
-    assert_equal "contents", session.buffer
-    assert_raises(ArgumentError) { session.timeout = Float::INFINITY }
-    assert_raises(ArgumentError) { session.write_timeout = -1 }
-    assert_raises(ArgumentError) { session.debug_level = 1.5 }
-    assert_equal [1, 2, 1], [session.timeout, session.write_timeout, session.debug_level]
-    session.buffer_limit = 4
-    assert_equal "ents", session.buffer
-  end
-
-  def test_predicates_use_ruby_truthiness_and_normalize_boolean_attributes
-    Expect.configure(raw_pty: 0, log_stdout: nil)
-    config = Expect.configuration
-    assert_equal true, config.raw_pty
-    assert_equal false, config.log_stdout
-    session, = pipe_session
-    assert session.raw_pty?
-    refute session.log_stdout?
-    session.preserve_buffer = 0
-    assert session.preserve_buffer?
-    session.preserve_buffer = nil
-    refute session.preserve_buffer?
-    assert_raises(ArgumentError) { session.timeout(1) }
-    assert_raises(ArgumentError) { session.log_stdout(true) }
-  end
-end