nio4r 2.0.0.pre-java → 2.1.0-java

data/spec/nio/monitor_spec.rb

@@ -1,113 +1,156 @@
+# 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) { "localhost" }
+  let(:port) { next_available_tcp_port }
 
-  let(:reader) { example_peers.first }
-  let(:writer) { example_peers.last }
+  let(:reader) { TCPServer.new(addr, 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 "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 IO object" do
-    expect(subject.io).to eq(reader)
+    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 "knows its selector" do
-    expect(subject.selector).to eq(selector)
-  end
+  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 "stores arbitrary values" do
-    subject.value = 42
-    expect(subject.value).to eq(42)
+    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,8 +18,9 @@ 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()

data/spec/nio/selectables/ssl_socket_spec.rb

@@ -1,8 +1,11 @@
+# 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
+  let(:addr) { "localhost" }
+  let(:port) { next_available_tcp_port }
 
   let(:ssl_key) { OpenSSL::PKey::RSA.new(1024) }
 
@@ -29,8 +32,8 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
   end
 
   let :readable_subject do
-    server = TCPServer.new("localhost", tcp_port)
-    client = TCPSocket.open("localhost", tcp_port)
+    server = TCPServer.new(addr, port)
+    client = TCPSocket.open(addr, port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -52,8 +55,8 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
   end
 
   let :unreadable_subject do
-    server = TCPServer.new("localhost", tcp_port + 1)
-    client = TCPSocket.new("localhost", tcp_port + 1)
+    server = TCPServer.new(addr, port)
+    client = TCPSocket.new(addr, port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -72,8 +75,8 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
   end
 
   let :writable_subject do
-    server = TCPServer.new("localhost", tcp_port + 2)
-    client = TCPSocket.new("localhost", tcp_port + 2)
+    server = TCPServer.new(addr, port)
+    client = TCPSocket.new(addr, port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -92,8 +95,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, port)
+    client = TCPSocket.new(addr, port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
@@ -140,8 +143,8 @@ RSpec.describe OpenSSL::SSL::SSLSocket, if: RUBY_VERSION >= "1.9.0" do
   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, port)
+    client = TCPSocket.new(addr, port)
     peer = server.accept
 
     ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)

data/spec/nio/selectables/tcp_socket_spec.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe TCPSocket do
-  port_offset = 0
-  let(:tcp_port) { 12_345 + (port_offset += 1) }
+  let(:addr) { "127.0.0.1" }
+  let(:port) { next_available_tcp_port }
 
   let :readable_subject do
-    server = TCPServer.new("localhost", tcp_port)
-    sock = TCPSocket.open("localhost", tcp_port)
+    server = TCPServer.new(addr, port)
+    sock = TCPSocket.new(addr, port)
     peer = server.accept
     peer << "data"
     sock
   end
 
   let :unreadable_subject do
-    TCPServer.new("localhost", tcp_port)
-    sock = TCPSocket.new("localhost", tcp_port)
+    TCPServer.new(addr, port)
+    sock = TCPSocket.new(addr, port)
 
     # Sanity check to make sure we actually produced an unreadable socket
     if select([sock], [], [], 0)
@@ -25,21 +27,25 @@ RSpec.describe TCPSocket do
   end
 
   let :writable_subject do
-    TCPServer.new("localhost", tcp_port)
-    TCPSocket.new("localhost", tcp_port)
+    TCPServer.new(addr, port)
+    TCPSocket.new(addr, port)
   end
 
   let :unwritable_subject do
-    server = TCPServer.new("localhost", tcp_port)
-    sock = TCPSocket.open("localhost", tcp_port)
-    peer = server.accept
+    server = TCPServer.new(addr, port)
+    sock = TCPSocket.new(addr, port)
 
-    begin
+    # TODO: close this socket
+    _peer = server.accept
+
+    loop do
       sock.write_nonblock "X" * 1024
-      _, writers = select [], [sock], [], 0
-    end while writers && writers.include?(sock)
+      _, writers = Kernel.select([], [sock], [], 0)
 
-    # I think the kernel might manage to drain its buffer a bit even after
+      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
@@ -59,8 +65,8 @@ RSpec.describe TCPSocket do
   end
 
   let :pair do
-    server = TCPServer.new("localhost", tcp_port)
-    client = TCPSocket.open("localhost", tcp_port)
+    server = TCPServer.new(addr, port)
+    client = TCPSocket.new(addr, port)
     [client, server.accept]
   end
 
@@ -69,20 +75,25 @@ RSpec.describe TCPSocket do
   it_behaves_like "an NIO bidirectional stream"
 
   context :connect do
-    it "selects writable when connected" do
-      selector = NIO::Selector.new
-      server = TCPServer.new("127.0.0.1", tcp_port)
-
-      client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-      monitor = selector.register(client, :w)
-
-      expect do
-        client.connect_nonblock Socket.sockaddr_in(tcp_port, "127.0.0.1")
-      end.to raise_exception Errno::EINPROGRESS
-
-      expect(selector.select(0.001)).to include monitor
-      result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
-      expect(result.unpack("i").first).to be_zero
+    it "selects writable when connected", retry: 5 do # retry: Flaky on OS X
+      begin
+        server = TCPServer.new(addr, port)
+        selector = NIO::Selector.new
+
+        client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        monitor = selector.register(client, :w)
+
+        expect do
+          client.connect_nonblock Socket.sockaddr_in(port, addr)
+        end.to raise_exception Errno::EINPROGRESS
+
+        expect(selector.select(0.001)).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,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe UDPSocket do

data/spec/nio/selector_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "timeout"
 
@@ -11,6 +13,12 @@ RSpec.describe NIO::Selector do
   let(:reader) { pair.first }
   let(:writer) { pair.last }
 
+  context "backend" do
+    it "knows its backend" do
+      expect(subject.backend).to be_a Symbol
+    end
+  end
+
   context "register" do
     it "registers IO objects" do
       monitor = subject.register(reader, :r)
@@ -43,9 +51,7 @@ RSpec.describe NIO::Selector do
 
   it "reports if it is empty" do
     expect(subject).to be_empty
-
-    monitor = subject.register(reader, :r)
-
+    subject.register(reader, :r)
     expect(subject).not_to be_empty
   end
 
@@ -96,7 +102,7 @@ RSpec.describe NIO::Selector do
 
       thread = Thread.new do
         started_at = Time.now
-        expect(subject.select).to be_nil
+        expect(subject.select).to eq []
         Time.now - started_at
       end