nio4r 2.5.8 → 2.7.4

data/spec/nio/selectables/ssl_socket_spec.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe OpenSSL::SSL::SSLSocket do
-
-  require "openssl"
-
-  before(:all) do
-    @tls = []
-  end
-
-  let(:addr) { "127.0.0.1" }
-
-  let(:ssl_key) { OpenSSL::PKey::RSA.new(2048) }
-
-  let(:ssl_cert) do
-    name = OpenSSL::X509::Name.new([%w[CN 127.0.0.1]])
-    OpenSSL::X509::Certificate.new.tap do |cert|
-      cert.version = 2
-      cert.serial = 1
-      cert.issuer = name
-      cert.subject = name
-      cert.not_before = Time.now
-      cert.not_after = Time.now + (7 * 24 * 60 * 60)
-      cert.public_key = ssl_key.public_key
-
-      cert.sign(ssl_key, OpenSSL::Digest::SHA256.new)
-    end
-  end
-
-  let(:ssl_server_context) do
-    OpenSSL::SSL::SSLContext.new.tap do |ctx|
-      ctx.cert = ssl_cert
-      ctx.key = ssl_key
-      unless @tls.empty?
-        if ctx.respond_to? :set_minmax_proto_version, true
-          ctx.max_version = @tls[0]
-        else
-          ctx.ssl_version = @tls[1]
-        end
-      end
-    end
-  end
-
-  let :readable_subject do
-    server = TCPServer.new(addr, 0)
-    client = TCPSocket.open(addr, server.local_address.ip_port)
-    peer = server.accept
-
-    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
-    ssl_peer.sync_close = true
-
-    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
-    ssl_client.sync_close = true
-
-    # SSLSocket#connect and #accept are blocking calls.
-    thread = Thread.new { ssl_client.connect }
-
-    ssl_peer.accept
-    ssl_peer << "data"
-    ssl_peer.flush
-
-    thread.join
-
-    pending "Failed to produce a readable socket" unless select([ssl_client], [], [], 10)
-    ssl_client
-  end
-
-  let :unreadable_subject do
-    server = TCPServer.new(addr, 0)
-    client = TCPSocket.new(addr, server.local_address.ip_port)
-    peer = server.accept
-
-    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
-    ssl_peer.sync_close = true
-
-    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
-    ssl_client.sync_close = true
-
-    # SSLSocket#connect and #accept are blocking calls.
-    thread = Thread.new { ssl_client.connect }
-    ssl_peer.accept
-    thread.join
-
-    if ssl_client.ssl_version == "TLSv1.3"
-      expect(ssl_client.read_nonblock(1, exception: false)).to eq(:wait_readable)
-    end
-
-    pending "Failed to produce an unreadable socket" if select([ssl_client], [], [], 0)
-    ssl_client
-  end
-
-  let :writable_subject do
-    server = TCPServer.new(addr, 0)
-    client = TCPSocket.new(addr, server.local_address.ip_port)
-    peer = server.accept
-
-    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
-    ssl_peer.sync_close = true
-
-    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
-    ssl_client.sync_close = true
-
-    # SSLSocket#connect and #accept are blocking calls.
-    thread = Thread.new { ssl_client.connect }
-
-    ssl_peer.accept
-    thread.join
-
-    ssl_client
-  end
-
-  let :unwritable_subject do
-    server = TCPServer.new(addr, 0)
-    client = TCPSocket.new(addr, server.local_address.ip_port)
-    peer = server.accept
-
-    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
-    ssl_peer.sync_close = true
-
-    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
-    ssl_client.sync_close = true
-
-    # SSLSocket#connect and #accept are blocking calls.
-    thread = Thread.new { ssl_client.connect }
-
-    ssl_peer.accept
-    thread.join
-
-    cntr = 0
-    begin
-      count = ssl_client.write_nonblock "X" * 1024
-      expect(count).not_to eq(0)
-      cntr += 1
-      t = select [], [ssl_client], [], 0
-    rescue IO::WaitReadable, IO::WaitWritable
-      pending "SSL will report writable but not accept writes"
-    end while t && t[1].include?(ssl_client) && cntr < 30
-
-    # I think the kernel might manage to drain its buffer a bit even after
-    # the socket first goes unwritable. Attempt to sleep past this and then
-    # attempt to write again
-    sleep 0.1
-
-    # Once more for good measure!
-    begin
-      # ssl_client.write_nonblock "X" * 1024
-      loop { ssl_client.write_nonblock "X" * 1024 }
-    rescue OpenSSL::SSL::SSLError
-    end
-
-    # Sanity check to make sure we actually produced an unwritable socket
-    if select([], [ssl_client], [], 0)
-      pending "Failed to produce an unwritable socket"
-    end
-
-    ssl_client
-  end
-
-  let :pair do
-    server = TCPServer.new(addr, 0)
-    client = TCPSocket.new(addr, server.local_address.ip_port)
-    peer = server.accept
-
-    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
-    ssl_peer.sync_close = true
-
-    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
-    ssl_client.sync_close = true
-
-    # SSLSocket#connect and #accept are blocking calls.
-    thread = Thread.new { ssl_client.connect }
-    ssl_peer.accept
-
-    [thread.value, ssl_peer]
-  end
-
-  describe "using TLS 1.2" do
-    before(:all) do
-      @tls = %i[TLS1_2 TLSv1_2]
-    end
-    it_behaves_like "an NIO selectable"
-    it_behaves_like "an NIO selectable stream"
-  end
-
-  describe "using TLS 1.3", if: OpenSSL::SSL.const_defined?(:TLS1_3_VERSION) do
-    before(:all) do
-      @tls = %i[TLS1_3 TLSv1_3]
-    end
-    it_behaves_like "an NIO selectable"
-    it_behaves_like "an NIO selectable stream", true
-  end
-end

data/spec/nio/selectables/tcp_socket_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe TCPSocket do
-  let(:addr) { "127.0.0.1" }
-
-  let :readable_subject do
-    server = TCPServer.new(addr, 0)
-    sock = TCPSocket.new(addr, server.local_address.ip_port)
-    peer = server.accept
-
-    peer << "Xdata"
-    peer.flush
-    sock.read(1)
-
-    sock
-  end
-
-  let :unreadable_subject do
-    server = TCPServer.new(addr, 0)
-    sock = TCPSocket.new(addr, server.local_address.ip_port)
-
-    # Sanity check to make sure we actually produced an unreadable socket
-    pending "Failed to produce an unreadable socket" if select([sock], [], [], 0)
-
-    sock
-  end
-
-  let :writable_subject do
-    server = TCPServer.new(addr, 0)
-    TCPSocket.new(addr, server.local_address.ip_port)
-  end
-
-  let :unwritable_subject do
-    server = TCPServer.new(addr, 0)
-    sock = TCPSocket.new(addr, server.local_address.ip_port)
-
-    # TODO: close this socket
-    _peer = server.accept
-
-    loop do
-      sock.write_nonblock "X" * 1024
-      _, writers = Kernel.select([], [sock], [], 0)
-
-      break unless writers && writers.include?(sock)
-    end
-
-    # HAX: I think the kernel might manage to drain its buffer a bit even after
-    # the socket first goes unwritable. Attempt to sleep past this and then
-    # attempt to write again
-    sleep 0.1
-
-    # Once more for good measure!
-    begin
-      sock.write_nonblock "X" * 1024
-    rescue Errno::EWOULDBLOCK
-    end
-
-    # Sanity check to make sure we actually produced an unwritable socket
-    pending "Failed to produce an unwritable socket" if select([], [sock], [], 0)
-
-    sock
-  end
-
-  let :pair do
-    server = TCPServer.new(addr, 0)
-    client = TCPSocket.new(addr, server.local_address.ip_port)
-    [client, server.accept]
-  end
-
-  it_behaves_like "an NIO selectable"
-  it_behaves_like "an NIO selectable stream"
-  it_behaves_like "an NIO bidirectional stream"
-
-  context :connect do
-    include_context NIO::Selector
-
-    it "selects writable when connected" do
-      begin
-        server = TCPServer.new(addr, 0)
-
-        client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-        monitor = selector.register(client, :w)
-
-        expect do
-          client.connect_nonblock server.local_address
-        end.to raise_exception Errno::EINPROGRESS
-
-        ready = selector.select(1)
-
-        expect(ready).to include monitor
-        result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
-        expect(result.unpack("i").first).to be_zero
-      ensure
-        server.close rescue nil
-        selector.close rescue nil
-      end
-    end
-  end
-end

data/spec/nio/selectables/udp_socket_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe UDPSocket, if: !defined?(JRUBY_VERSION) do
-  let(:udp_port) { 23_456 }
-
-  let :readable_subject do
-    server = UDPSocket.new
-    server.bind("127.0.0.1", 0)
-
-    peer = UDPSocket.new
-    peer.send("hi there", 0, "127.0.0.1", server.local_address.ip_port)
-
-    server
-  end
-
-  let :unreadable_subject do
-    sock = UDPSocket.new
-    sock.bind("127.0.0.1", 0)
-    sock
-  end
-
-  let :writable_subject do
-    server = UDPSocket.new
-    server.bind("127.0.0.1", 0)
-
-    peer = UDPSocket.new
-    peer.connect("127.0.0.1", server.local_address.ip_port)
-
-    cntr = 0
-    begin
-      peer.send("X" * 1024, 0)
-      cntr += 1
-      t = select [], [peer], [], 0
-    rescue Errno::ECONNREFUSED => e
-      skip "Couldn't make writable UDPSocket subject: #{e.class}: #{e}"
-    end while t && t[1].include?(peer) && cntr < 5
-
-    peer
-  end
-
-  let :unwritable_subject do
-    pending "come up with a UDPSocket that's blocked on writing"
-  end
-
-  it_behaves_like "an NIO selectable"
-end

data/spec/nio/selector_spec.rb

@@ -1,240 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "timeout"
-
-RSpec.describe NIO::Selector do
-  let(:pair)   { IO.pipe }
-  let(:reader) { pair.first }
-  let(:writer) { pair.last }
-
-  context ".backends" do
-    it "knows all supported backends" do
-      expect(described_class.backends).to be_a Array
-      expect(described_class.backends.first).to be_a Symbol
-    end
-  end
-
-  context "#initialize" do
-    it "allows explicitly specifying a backend" do |example|
-      backend = described_class.backends.first
-      selector = described_class.new(backend)
-      expect(selector.backend).to eq backend
-
-      example.reporter.message "Supported backends: #{described_class.backends}"
-    end
-
-    it "automatically selects a backend if none or nil is specified" do
-      expect(described_class.new.backend).to eq described_class.new(nil).backend
-    end
-
-    it "raises ArgumentError if given an invalid backend" do
-      expect { described_class.new(:derp) }.to raise_error ArgumentError
-    end
-
-    it "raises TypeError if given a non-Symbol parameter" do
-      expect { described_class.new(42).to raise_error TypeError }
-    end
-  end
-
-  context "backend" do
-    it "knows its backend" do |example|
-      expect(subject.backend).to be_a Symbol
-
-      example.reporter.message "Current backend: #{subject.backend}"
-    end
-  end
-
-  context "register" do
-    it "registers IO objects" do
-      monitor = subject.register(reader, :r)
-      expect(monitor).not_to be_closed
-    end
-
-    it "raises TypeError if asked to register non-IO objects" do
-      expect { subject.register(42, :r) }.to raise_exception TypeError
-    end
-
-    it "raises when asked to register after closing" do
-      subject.close
-      expect { subject.register(reader, :r) }.to raise_exception IOError
-    end
-  end
-
-  it "knows which IO objects are registered" do
-    subject.register(reader, :r)
-    expect(subject).to be_registered(reader)
-    expect(subject).not_to be_registered(writer)
-  end
-
-  it "deregisters IO objects" do
-    subject.register(reader, :r)
-
-    monitor = subject.deregister(reader)
-    expect(subject).not_to be_registered(reader)
-    expect(monitor).to be_closed
-  end
-
-  it "allows deregistering closed IO objects" do
-    subject.register(reader, :r)
-    reader.close
-
-    expect do
-      subject.deregister(reader)
-    end.not_to raise_error
-  end
-
-  it "reports if it is empty" do
-    expect(subject).to be_empty
-    subject.register(reader, :r)
-    expect(subject).not_to be_empty
-  end
-
-  # This spec might seem a bit silly, but this actually something the
-  # Java NIO API specifically precludes that we need to work around
-  it "allows reregistration of the same IO object across select calls" do
-    monitor = subject.register(reader, :r)
-    writer << "ohai"
-
-    expect(subject.select).to include monitor
-    expect(reader.read(4)).to eq("ohai")
-    subject.deregister(reader)
-
-    new_monitor = subject.register(reader, :r)
-    writer << "thar"
-    expect(subject.select).to include new_monitor
-    expect(reader.read(4)).to eq("thar")
-  end
-
-  context "timeouts" do
-    let(:select_precision) {0.2}
-    let(:timeout) {2.0}
-    let(:payload) {"hi there"}
-
-    it "waits for timeout when selecting from empty selector" do
-      started_at = Time.now
-      expect(subject.select(timeout)).to be_nil
-      expect(Time.now - started_at).to be_within(select_precision).of(timeout)
-    end
-
-    it "waits for a timeout when selecting with reader" do
-      monitor = subject.register(reader, :r)
-
-      writer << payload
-
-      started_at = Time.now
-      expect(subject.select(timeout)).to include monitor
-      expect(Time.now - started_at).to be_within(select_precision).of(0)
-      reader.read_nonblock(payload.size)
-
-      started_at = Time.now
-      expect(subject.select(timeout)).to be_nil
-      expect(Time.now - started_at).to be_within(select_precision).of(timeout)
-    end
-
-    it "raises ArgumentError if given a negative timeout" do
-      subject.register(reader, :r)
-
-      expect do
-        subject.select(-1)
-      end.to raise_exception(ArgumentError)
-    end
-  end
-
-  context "wakeup" do
-    let(:select_precision) {0.2}
-
-    it "wakes up if signaled to from another thread" do
-      subject.register(reader, :r)
-
-      thread = Thread.new do
-        started_at = Time.now
-        expect(subject.select).to eq []
-        Time.now - started_at
-      end
-
-      timeout = 0.1
-      sleep timeout
-      subject.wakeup
-
-      expect(thread.value).to be_within(select_precision).of(timeout)
-    end
-
-    it "raises IOError if asked to wake up a closed selector" do
-      subject.close
-      expect(subject).to be_closed
-
-      expect { subject.wakeup }.to raise_exception IOError
-    end
-  end
-
-  context "select" do
-    it "does not block on super small precision intervals" do
-      wait_interval = 1e-4
-
-      expect do
-        Timeout.timeout(2) do
-          subject.select(wait_interval)
-        end
-      end.not_to raise_error
-    end
-
-    it "selects IO objects" do
-      writer << "ohai"
-      unready = IO.pipe.first
-
-      reader_monitor  = subject.register(reader, :r)
-      unready_monitor = subject.register(unready, :r)
-
-      selected = subject.select(0)
-      expect(selected.size).to eq(1)
-      expect(selected).to include reader_monitor
-      expect(selected).not_to include unready_monitor
-    end
-
-    it "selects closed IO objects" do
-      monitor = subject.register(reader, :r)
-      expect(subject.select(0)).to be_nil
-
-      thread = Thread.new { subject.select }
-      Thread.pass while thread.status && thread.status != "sleep"
-
-      writer.close
-      selected = thread.value
-      expect(selected).to include monitor
-    end
-
-    it "iterates across selected objects with a block" do
-      readable1, writer = IO.pipe
-      writer << "ohai"
-
-      readable2, writer = IO.pipe
-      writer << "ohai"
-
-      unreadable = IO.pipe.first
-
-      monitor1 = subject.register(readable1, :r)
-      monitor2 = subject.register(readable2, :r)
-      monitor3 = subject.register(unreadable, :r)
-
-      readables = []
-      result = subject.select { |monitor| readables << monitor }
-      expect(result).to eq(2)
-
-      expect(readables).to include monitor1
-      expect(readables).to include monitor2
-      expect(readables).not_to include monitor3
-    end
-
-    it "raises IOError if asked to select on a closed selector" do
-      subject.close
-
-      expect { subject.select(0) }.to raise_exception IOError
-    end
-  end
-
-  it "closes" do
-    subject.close
-    expect(subject).to be_closed
-  end
-end

data/spec/spec_helper.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "coveralls"
-Coveralls.wear!
-
-require "nio"
-require "support/selectable_examples"
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = ".rspec_status"
-
-  config.filter_run_when_matching :focus
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end

data/spec/support/selectable_examples.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_context NIO::Selector do
-  let(:selector) {@selector = NIO::Selector.new}
-
-  after(:each) do
-    if defined?(@selector)
-      @selector.close
-    end
-  end
-end
-
-RSpec.shared_context "an NIO selectable" do
-  include_context NIO::Selector
-
-  it "selects readable objects" do
-    monitor = selector.register(readable_subject, :r)
-    ready = selector.select(1)
-    expect(ready).to be_an Enumerable
-    expect(ready).to include monitor
-  end
-
-  it "does not select unreadable objects" do
-    selector.register(unreadable_subject, :r)
-    expect(selector.select(0)).to be_nil
-  end
-
-  it "selects writable objects" do
-    monitor = selector.register(writable_subject, :w)
-    ready = selector.select(1)
-    expect(ready).to be_an Enumerable
-    expect(ready).to include monitor
-  end
-
-  it "does not select unwritable objects" do
-    selector.register(unwritable_subject, :w)
-    ready = selector.select(0)
-    expect(ready).to be_nil
-  end
-end
-
-RSpec.shared_context "an NIO selectable stream" do |is_tls13|
-  include_context NIO::Selector
-
-  let(:stream)   { pair.first }
-  let(:peer)     { pair.last }
-
-  it "selects readable when the other end closes" do
-    monitor = selector.register(stream, :r)
-    unless is_tls13
-      expect(selector.select(1)).to be_nil
-    end
-
-    peer.close
-    # Wait and give the TCP session time to close
-    expect(selector.select(0.1)).to include monitor
-  end
-end
-
-RSpec.shared_context "an NIO bidirectional stream" do
-  include_context NIO::Selector
-
-  let(:stream) {pair.first}
-  let(:peer) {pair.last}
-
-  it "selects readable and writable" do
-    selector.register(readable_subject, :rw)
-
-    selector.select(1) do |monitor|
-      expect(monitor.readiness).to eq(:rw)
-    end
-
-    readable_subject.close
-  end
-
-  it "keeps readiness after the selectable has been closed" do
-    selector.register(readable_subject, :rw)
-
-    selector.select(1) do |monitor|
-      expect(monitor.readiness).to eq(:rw)
-      readable_subject.close
-      expect(monitor.readiness).to eq(:rw)
-    end
-  end
-end