nio4r 1.2.1 → 2.5.3

data/spec/nio/monitor_spec.rb

@@ -1,113 +1,162 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "socket"
 
 RSpec.describe NIO::Monitor do
-  let(:example_peers) do
-    address   = "127.0.0.1"
-    base_port = 12_345
-    tries     = 10
-
-    server = tries.times do |n|
-      begin
-        break TCPServer.new(address, base_port + n)
-      rescue Errno::EADDRINUSE
-        retry
-      end
-    end
-
-    fail Errno::EADDRINUSE, "couldn't find an open port" unless server
-    client = TCPSocket.new(address, server.addr[1])
-    [server, client]
-  end
+  let(:addr) { "127.0.0.1" }
 
-  let(:reader) { example_peers.first }
-  let(:writer) { example_peers.last }
+  let(:reader) { TCPServer.new(addr, 0) }
+  let(:port) { reader.local_address.ip_port }
+  let(:writer) { TCPSocket.new(addr, port) }
 
   let(:selector) { NIO::Selector.new }
 
-  subject    { selector.register(reader, :r) }
-  let(:peer) { selector.register(writer, :rw) }
-  after      { selector.close }
+  subject(:monitor) { selector.register(writer, :rw) }
+  subject(:peer)    { selector.register(reader, :r) }
 
-  before     { example_peers } # open server and client automatically
-  after      { reader.close }
-  after      { writer.close }
+  before { reader }
+  before { writer }
+  after  { reader.close }
+  after  { writer.close }
+  after  { selector.close }
 
-  it "knows its interests" do
-    expect(subject.interests).to eq(:r)
-    expect(peer.interests).to eq(:rw)
+  describe "#interests" do
+    it "knows its interests" do
+      expect(peer.interests).to eq(:r)
+      expect(monitor.interests).to eq(:rw)
+    end
   end
 
-  it "changes the interest set" do
-    expect(peer.interests).not_to eq(:w)
-    peer.interests = :w
-    expect(peer.interests).to eq(:w)
-  end
+  describe "#interests=" do
+    it "can set interests to nil" do
+      expect(monitor.interests).not_to eq(nil)
+      monitor.interests = nil
+      expect(monitor.interests).to eq(nil)
+    end
 
-  it "knows its IO object" do
-    expect(subject.io).to eq(reader)
-  end
+    it "changes the interest set" do
+      expect(monitor.interests).not_to eq(:w)
+      monitor.interests = :w
+      expect(monitor.interests).to eq(:w)
+    end
 
-  it "knows its selector" do
-    expect(subject.selector).to eq(selector)
+    it "raises EOFError if interests are changed after the monitor is closed" do
+      monitor.close
+      expect { monitor.interests = :rw }.to raise_error(EOFError)
+    end
   end
 
-  it "stores arbitrary values" do
-    subject.value = 42
-    expect(subject.value).to eq(42)
+  describe "#add_interest" do
+    it "sets a new interest if it isn't currently registered" do
+      monitor.interests = :r
+      expect(monitor.interests).to eq(:r)
+
+      expect(monitor.add_interest(:w)).to eq(:rw)
+      expect(monitor.interests).to eq(:rw)
+    end
+
+    it "acts idempotently" do
+      monitor.interests = :r
+      expect(monitor.interests).to eq(:r)
+
+      expect(monitor.add_interest(:r)).to eq(:r)
+      expect(monitor.interests).to eq(:r)
+    end
+
+    it "raises ArgumentError if given a bogus option" do
+      expect { monitor.add_interest(:derp) }.to raise_error(ArgumentError)
+    end
   end
 
-  it "knows what operations IO objects are ready for" do
-    # For whatever odd reason this breaks unless we eagerly evaluate subject
-    reader_monitor = subject
-    writer_monitor = peer
+  describe "#remove_interest" do
+    it "removes an interest from the set" do
+      expect(monitor.interests).to eq(:rw)
+
+      expect(monitor.remove_interest(:r)).to eq(:w)
+      expect(monitor.interests).to eq(:w)
+    end
 
-    selected = selector.select(0)
-    expect(selected).to include(writer_monitor)
+    it "can clear the last interest" do
+      monitor.interests = :w
+      expect(monitor.interests).to eq(:w)
 
-    expect(writer_monitor.readiness).to eq(:w)
-    expect(writer_monitor).not_to be_readable
-    expect(writer_monitor).to be_writable
+      expect(monitor.remove_interest(:w)).to be_nil
+      expect(monitor.interests).to be_nil
+    end
 
-    writer << "testing 1 2 3"
+    it "acts idempotently" do
+      monitor.interests = :w
+      expect(monitor.interests).to eq(:w)
 
-    selected = selector.select(0)
-    expect(selected).to include(reader_monitor)
+      expect(monitor.remove_interest(:r)).to eq(:w)
+      expect(monitor.interests).to eq(:w)
+    end
 
-    expect(reader_monitor.readiness).to eq(:r)
-    expect(reader_monitor).to be_readable
-    expect(reader_monitor).not_to be_writable
+    it "raises ArgumentError if given a bogus option" do
+      expect { monitor.add_interest(:derp) }.to raise_error(ArgumentError)
+    end
   end
 
-  it "changes current interests with #interests=" do
-    client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-    monitor = selector.register(client, :r)
-    expect(monitor.interests).to eq(:r)
-    monitor.interests = :w
-    expect(monitor.interests).to eq(:w)
+  describe "#io" do
+    it "knows its IO object" do
+      expect(monitor.io).to eq(writer)
+    end
   end
 
-  it "closes" do
-    expect(subject).not_to be_closed
-    expect(selector.registered?(reader)).to be_truthy
+  describe "#selector" do
+    it "knows its selector" do
+      expect(monitor.selector).to eq(selector)
+    end
+  end
 
-    subject.close
-    expect(subject).to be_closed
-    expect(selector.registered?(reader)).to be_falsey
+  describe "#value=" do
+    it "stores arbitrary values" do
+      monitor.value = 42
+      expect(monitor.value).to eq(42)
+    end
   end
 
-  it "closes even if the selector has been shutdown" do
-    expect(subject).not_to be_closed
-    selector.close # forces shutdown
-    expect(subject).not_to be_closed
-    subject.close
-    expect(subject).to be_closed
+  describe "#readiness" do
+    it "knows what operations IO objects are ready for" do
+      # For whatever odd reason this breaks unless we eagerly evaluate monitor
+      reader_peer = peer
+      writer_peer = monitor
+
+      selected = selector.select(0)
+      expect(selected).to include(writer_peer)
+
+      expect(writer_peer.readiness).to eq(:w)
+      expect(writer_peer).not_to be_readable
+      expect(writer_peer).to be_writable
+
+      writer << "testing 1 2 3"
+
+      selected = selector.select(0)
+      expect(selected).to include(reader_peer)
+
+      expect(reader_peer.readiness).to eq(:r)
+      expect(reader_peer).to be_readable
+      expect(reader_peer).not_to be_writable
+    end
   end
 
-  it "changes the interest set after monitor closed" do
-    # check for changing the interests on the go after closed expected to fail
-    expect(subject.interests).not_to eq(:rw)
-    subject.close # forced shutdown
-    expect { subject.interests = :rw }.to raise_error(TypeError)
+  describe "#close" do
+    it "closes" do
+      expect(monitor).not_to be_closed
+      expect(selector.registered?(writer)).to be_truthy
+
+      monitor.close
+      expect(monitor).to be_closed
+      expect(selector.registered?(writer)).to be_falsey
+    end
+
+    it "closes even if the selector has been shutdown" do
+      expect(monitor).not_to be_closed
+      selector.close # forces shutdown
+      expect(monitor).not_to be_closed
+      monitor.close
+      expect(monitor).to be_closed
+    end
   end
 end

data/spec/nio/selectables/pipe_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe "IO.pipe" do
@@ -6,6 +8,7 @@ RSpec.describe "IO.pipe" do
   let :unreadable_subject do
     pair.first
   end
+
   let :readable_subject do
     pipe, peer = pair
     peer << "data"
@@ -15,20 +18,26 @@ RSpec.describe "IO.pipe" do
   let :writable_subject do
     pair.last
   end
+
   let :unwritable_subject do
-    reader, pipe = IO.pipe
+    _reader, pipe = pair
 
     # HACK: On OS X 10.8, this str must be larger than PIPE_BUF. Otherwise,
     #      the write is atomic and select() will return writable but write()
     #      will throw EAGAIN if there is too little space to write the string
     # TODO: Use FFI to lookup the platform-specific size of PIPE_BUF
     str = "JUNK IN THE TUBES" * 10_000
+    cntr = 0
     begin
       pipe.write_nonblock str
-      _, writers = select [], [pipe], [], 0
+      cntr += 1
+      t = select [], [pipe], [], 0
     rescue Errno::EPIPE
       break
-    end while writers && writers.include?(pipe)
+    rescue IO::EWOULDBLOCKWaitWritable
+      skip "windows - can't test due to 'select' not showing correct status"
+      break
+    end while t && t[1].include?(pipe) && cntr < 20
 
     pipe
   end

data/spec/nio/selectables/ssl_socket_spec.rb

@@ -1,23 +1,31 @@
+# frozen_string_literal: true
+
 require "spec_helper"
-require "openssl"
 
-RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
-  let(:tcp_port) { 34_567 }
+RSpec.describe OpenSSL::SSL::SSLSocket do
+
+  require "openssl"
+
+  before(:all) do
+    @tls = []
+  end
 
-  let(:ssl_key) { OpenSSL::PKey::RSA.new(1024) }
+  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 localhost)])
+    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 + (365 * 24 * 60 * 60)
+      cert.not_after = Time.now + (7 * 24 * 60 * 60)
       cert.public_key = ssl_key.public_key
 
-      cert.sign(ssl_key, OpenSSL::Digest::SHA1.new)
+      cert.sign(ssl_key, OpenSSL::Digest::SHA256.new)
     end
   end
 
@@ -25,12 +33,19 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" 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("localhost", tcp_port)
-    client = TCPSocket.open("localhost", tcp_port)
+    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)
@@ -44,16 +59,17 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
 
     ssl_peer.accept
     ssl_peer << "data"
+    ssl_peer.flush
 
     thread.join
-    pending "Failed to produce a readable SSL socket" unless select([ssl_client], [], [], 0)
 
+    pending "Failed to produce a readable socket" unless select([ssl_client], [], [], 10)
     ssl_client
   end
 
   let :unreadable_subject do
-    server = TCPServer.new("localhost", tcp_port + 1)
-    client = TCPSocket.new("localhost", tcp_port + 1)
+    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)
@@ -67,13 +83,17 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
     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("localhost", tcp_port + 2)
-    client = TCPSocket.new("localhost", tcp_port + 2)
+    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)
@@ -92,8 +112,8 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
   end
 
   let :unwritable_subject do
-    server = TCPServer.new("localhost", tcp_port + 3)
-    client = TCPSocket.open("localhost", tcp_port + 3)
+    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)
@@ -108,14 +128,15 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
     ssl_peer.accept
     thread.join
 
+    cntr = 0
     begin
-      _, writers = select [], [ssl_client], [], 0
       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"
-      raise if writers.include? ssl_client
-    end while writers && writers.include?(ssl_client)
+    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
@@ -124,24 +145,22 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
 
     # Once more for good measure!
     begin
-      #        ssl_client.write_nonblock "X" * 1024
+      # 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
+    if select([], [ssl_client], [], 0)
+      pending "Failed to produce an unwritable socket"
+    end
 
     ssl_client
   end
 
   let :pair do
-    pending "figure out why newly created sockets are selecting readable immediately"
-
-    server = TCPServer.new("localhost", tcp_port + 4)
-    client = TCPSocket.open("localhost", tcp_port + 4)
+    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)
@@ -157,6 +176,19 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
     [thread.value, ssl_peer]
   end
 
-  it_behaves_like "an NIO selectable"
-  it_behaves_like "an NIO selectable stream"
+  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