celluloid-io 0.17.1 → 0.17.2

data/lib/celluloid/io/unix_socket.rb

@@ -1,4 +1,4 @@
-require 'socket'
+require "socket"
 
 module Celluloid
   module IO
@@ -10,7 +10,7 @@ module Celluloid
 
       # Open a UNIX connection.
       def self.open(socket_path, &block)
-        self.new(socket_path, &block)
+        new(socket_path, &block)
       end
 
       # Convert a Ruby UNIXSocket into a Celluloid::IO::UNIXSocket
@@ -31,9 +31,9 @@ module Celluloid
 
         # FIXME: not doing non-blocking connect
         @socket = if block
-          ::UNIXSocket.open(socket_path, &block)
-        else
-          ::UNIXSocket.new(socket_path)
+                    ::UNIXSocket.open(socket_path, &block)
+                  else
+                    ::UNIXSocket.new(socket_path)
         end
       end
 

data/lib/celluloid/io/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   module IO
-    VERSION = "0.17.1"
+    VERSION = "0.17.2"
   end
 end

data/spec/celluloid/io/actor_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO do
+RSpec.describe Celluloid::IO, library: :IO do
   it_behaves_like "a Celluloid Actor", Celluloid::IO
 end

data/spec/celluloid/io/dns_resolver_spec.rb

@@ -1,18 +1,18 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO::DNSResolver do
-  describe '#resolve' do
-    it 'resolves hostnames statically from hosts file without nameservers' do
+RSpec.describe Celluloid::IO::DNSResolver, library: :IO do
+  context '#resolve' do
+    it "resolves hostnames statically from hosts file without nameservers" do
       # /etc/resolv.conf doesn't exist on Mac OSX when no networking is
       # disabled, thus .nameservers would return nil
       expect(Celluloid::IO::DNSResolver).to receive(:nameservers).at_most(:once) { nil }
       resolver = Celluloid::IO::DNSResolver.new
-      expect(resolver.resolve('localhost')).to eq Resolv::IPv4.create("127.0.0.1")
+      expect(resolver.resolve("localhost")).to eq(Resolv::IPv4.create("127.0.0.1")).or eq(Resolv::IPv6.create("::1"))
     end
 
-    it 'resolves hostnames' do
+    it "resolves hostnames" do
       resolver = Celluloid::IO::DNSResolver.new
-      expect(resolver.resolve('localhost')).to eq Resolv::IPv4.create("127.0.0.1")
+      expect(resolver.resolve("localhost")).to eq(Resolv::IPv4.create("127.0.0.1")).or eq(Resolv::IPv6.create("::1"))
     end
 
     it "resolves domain names" do
@@ -26,7 +26,7 @@ describe Celluloid::IO::DNSResolver do
       resolver = Celluloid::IO::DNSResolver.new
       results = resolver.resolve("www.google.com")
       if results.is_a?(Array)
-        results.all? {|i| expect(i).to be_an_instance_of(Resolv::IPv4) }
+        results.all? { |i| expect(i).to be_an_instance_of(Resolv::IPv4) }
       else
         expect(results).to be_an_instance_of(Resolv::IPv4)
       end
@@ -34,7 +34,7 @@ describe Celluloid::IO::DNSResolver do
       # single entry.
       results = resolver.resolve("www.yahoo.com")
       if results.is_a?(Array)
-        results.all? {|i| expect(i).to be_an_instance_of(Resolv::IPv4) }
+        results.all? { |i| expect(i).to be_an_instance_of(Resolv::IPv4) }
       else
         expect(results).to be_an_instance_of(Resolv::IPv4)
       end

data/spec/celluloid/io/mailbox_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO::Mailbox do
+RSpec.describe Celluloid::IO::Mailbox, library: :IO do
   it_behaves_like "a Celluloid Mailbox"
 end

data/spec/celluloid/io/reactor_spec.rb

@@ -1,19 +1,19 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO::Reactor do
+RSpec.describe Celluloid::IO::Reactor, library: :IO do
   let(:payload) { "balls" }
   let(:example_port) { assign_port }
-  
+
   it "shouldn't crash" do
     server = ::TCPServer.new example_addr, example_port
-    
+
     thread = Thread.new { server.accept }
-    
+
     socket = within_io_actor { Celluloid::IO::TCPSocket.new example_addr, example_port }
     peer = thread.value
     peer_thread = Thread.new { loop { peer << payload } }
     handle = false
-    
+
     # Main server body:
     within_io_actor do
       begin
@@ -29,9 +29,9 @@ describe Celluloid::IO::Reactor do
         handle = true
       end
     end
-    
+
     expect(handle).to be_truthy
-    
+
     server.close
     peer.close
     socket.close

data/spec/celluloid/io/ssl_server_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO::SSLServer do
+RSpec.describe Celluloid::IO::SSLServer, library: :IO do
   let(:client_cert) { OpenSSL::X509::Certificate.new fixture_dir.join("client.crt").read }
   let(:client_key)  { OpenSSL::PKey::RSA.new fixture_dir.join("client.key").read }
   let(:client_context) do
@@ -9,7 +9,7 @@ describe Celluloid::IO::SSLServer do
       context.key  = client_key
     end
   end
-  
+
   let(:example_port) { assign_port }
   let(:server_cert) { OpenSSL::X509::Certificate.new fixture_dir.join("server.crt").read }
   let(:server_key)  { OpenSSL::PKey::RSA.new fixture_dir.join("server.key").read }
@@ -21,7 +21,7 @@ describe Celluloid::IO::SSLServer do
   end
 
   describe "#accept" do
-    let(:payload) { 'ohai' }
+    let(:payload) { "ohai" }
 
     context "inside Celluloid::IO" do
       it "should be evented" do
@@ -89,4 +89,3 @@ describe Celluloid::IO::SSLServer do
     end
   end
 end
-

data/spec/celluloid/io/ssl_socket_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
-require 'openssl'
+require "spec_helper"
+require "openssl"
 
-describe Celluloid::IO::SSLSocket do
-  let(:request)  { 'ping' }
-  let(:response) { 'pong' }
+RSpec.describe Celluloid::IO::SSLSocket, library: :IO do
+  let(:request)  { "ping" }
+  let(:response) { "pong" }
 
   let(:example_port) { assign_port }
   let(:client_cert) { OpenSSL::X509::Certificate.new fixture_dir.join("client.crt").read }
@@ -15,28 +15,28 @@ describe Celluloid::IO::SSLSocket do
     end
   end
 
-  after(:each) {
+  after(:each) do
     client.close rescue nil
     server.close rescue nil
-  }
+  end
 
   let(:client) do
     attempts = 0
     socket = begin
-    Timeout.timeout(MAX_TIME) {
-      begin
-        TCPSocket.new example_addr, example_port
-      rescue Errno::ECONNREFUSED
-        raise if attempts >= MAX_ATTEMPTS
-      attempts += 1
-        # HAX: sometimes this fails to connect? o_O
-        # ... This can often fail 20 times in a row ... so yeah
-        # This is quite likely due to the Thread.pass style spinlocks for startup
-        # Seems gimpy, but sleep and retry
-        sleep 0.0126
-        retry
+      Timeout.timeout(Specs::MAX_EXECUTION) do
+        begin
+          TCPSocket.new example_addr, example_port
+        rescue Errno::ECONNREFUSED
+          raise if attempts >= Specs::MAX_ATTEMPTS
+          attempts += 1
+          # HAX: sometimes this fails to connect? o_O
+          # ... This can often fail 20 times in a row ... so yeah
+          # This is quite likely due to the Thread.pass style spinlocks for startup
+          # Seems gimpy, but sleep and retry
+          sleep 0.0126
+          retry
+        end
       end
-    }
     rescue => ex
       attempted = "Tried #{attempts} times to instantiate socket."
       raise ex.class.new(attempted)
@@ -77,7 +77,7 @@ describe Celluloid::IO::SSLSocket do
   context "duck typing ::SSLSocket" do
     it "responds to #peeraddr" do
       with_ssl_sockets do |ssl_client, ssl_peer|
-        expect{ ssl_client.peeraddr }.to_not raise_error
+        expect { ssl_client.peeraddr }.to_not raise_error
       end
     end
   end
@@ -96,7 +96,7 @@ describe Celluloid::IO::SSLSocket do
     end
 
     it "starts SSL on a connected TCP socket" do
-      if RUBY_PLATFORM == 'java'
+      if RUBY_PLATFORM == "java"
         pending "JRuby support"
         fail "Bypassing potential deadlock."
       end
@@ -136,7 +136,7 @@ describe Celluloid::IO::SSLSocket do
     end
 
     it "starts SSL on a connected TCP socket" do
-      if RUBY_PLATFORM == 'java'
+      if RUBY_PLATFORM == "java"
         pending "JRuby support"
         fail "Bypassing potential deadlock."
       end
@@ -164,7 +164,7 @@ describe Celluloid::IO::SSLSocket do
 
   it "knows its cert" do
     # FIXME: seems bad? o_O
-    pending "wtf is wrong with this on JRuby" if RUBY_PLATFORM == 'java'
+    pending "wtf is wrong with this on JRuby" if RUBY_PLATFORM == "java"
     with_ssl_sockets do |ssl_client|
       expect(ssl_client.cert.to_der).to eq(client_cert.to_der)
     end
@@ -192,7 +192,7 @@ describe Celluloid::IO::SSLSocket do
 
   it "knows its client_ca" do
     # jruby-openssl does not implement this method
-    pending "jruby-openssl support" if RUBY_PLATFORM == 'java'
+    pending "jruby-openssl support" if RUBY_PLATFORM == "java"
 
     with_ssl_sockets do |ssl_client|
       expect(ssl_client.client_ca).to eq(ssl_client.to_io.client_ca)
@@ -201,7 +201,7 @@ describe Celluloid::IO::SSLSocket do
 
   it "verifies peer certificates" do
     # FIXME: JRuby seems to be giving the wrong result here o_O
-    pending "jruby-openssl support" if RUBY_PLATFORM == 'java'
+    pending "jruby-openssl support" if RUBY_PLATFORM == "java"
 
     with_ssl_sockets do |ssl_client, ssl_peer|
       expect(ssl_client.verify_result).to eq(OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT)

data/spec/celluloid/io/tcp_server_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO::TCPServer do
-  describe "#accept" do
-    let(:payload) { 'ohai' }
+RSpec.describe Celluloid::IO::TCPServer, library: :IO do
+  context "#accept" do
+    let(:payload) { "ohai" }
     let(:example_port) { assign_port }
 
     it "can be initialized without a host" do

data/spec/celluloid/io/tcp_socket_spec.rb

@@ -1,11 +1,11 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO::TCPSocket do
-  let(:payload) { 'ohai' }
+RSpec.describe Celluloid::IO::TCPSocket, library: :IO do
+  let(:payload) { "ohai" }
   let(:example_port) { assign_port }
+  let(:logger) { Specs::FakeLogger.current }
 
   context "inside Celluloid::IO" do
-
     describe ".open" do
       it "returns the open socket" do
         server = ::TCPServer.new example_addr, example_port
@@ -22,10 +22,10 @@ describe Celluloid::IO::TCPSocket do
         it "returns the block evaluation" do
           server = ::TCPServer.new example_addr, example_port
           thread = Thread.new { server.accept }
-  
+
           value = within_io_actor { Celluloid::IO::TCPSocket.open(example_addr, example_port) { true } }
           expect(value).to be_truthy
-  
+
           server.close
           thread.terminate
         end
@@ -102,44 +102,47 @@ describe Celluloid::IO::TCPSocket do
     end
 
     it "raises Errno::ECONNREFUSED when the connection is refused" do
-      expect {
+      allow(logger).to receive(:crash).with("Actor crashed!", Errno::ECONNREFUSED)
+      expect do
         within_io_actor { ::TCPSocket.new(example_addr, example_port) }
-      }.to raise_error(Errno::ECONNREFUSED)
+      end.to raise_error(Errno::ECONNREFUSED)
     end
 
-    context 'eof?' do
+    context "eof?" do
       it "blocks actor then returns by close" do
         with_connected_sockets(example_port) do |subject, peer|
           started_at = Time.now
-          Thread.new{ sleep 0.5; peer.close; }
+          Thread.new { sleep 0.5; peer.close; }
           within_io_actor { subject.eof? }
           expect(Time.now - started_at).to be > 0.5
         end
       end
-      
+
       it "blocks until gets the next byte" do
+        allow(logger).to receive(:crash).with("Actor crashed!", Celluloid::TaskTimeout)
         with_connected_sockets(example_port) do |subject, peer|
           peer << 0x00
           peer.flush
-          expect {
-            within_io_actor {
+          expect do
+            within_io_actor do
               subject.read(1)
-              Celluloid.timeout(0.5) {
+              Celluloid.timeout(0.5) do
                 expect(subject.eof?).to be_falsey
-              }
-            }
-          }.to raise_error(Celluloid::TaskTimeout)
+              end
+            end
+          end.to raise_error(Celluloid::TaskTimeout)
         end
       end
     end
 
     context "readpartial" do
       it "raises EOFError when reading from a closed socket" do
+        allow(logger).to receive(:crash).with("Actor crashed!", EOFError)
         with_connected_sockets(example_port) do |subject, peer|
           peer.close
-          expect {
+          expect do
             within_io_actor { subject.readpartial(payload.size) }
-          }.to raise_error(EOFError)
+          end.to raise_error(EOFError)
         end
       end
 
@@ -147,7 +150,8 @@ describe Celluloid::IO::TCPSocket do
         pending "not implemented"
 
         with_connected_sockets(example_port) do |subject, peer|
-          actor = ExampleActor.new
+          actor = with_wrapper_actor
+          allow(logger).to receive(:crash).with("Actor crashed!", IOError)
           begin
             read_future = actor.future.wrap do
               subject.readpartial(payload.size)
@@ -164,7 +168,8 @@ describe Celluloid::IO::TCPSocket do
       it "raises IOError when partial reading from a socket the peer closed" do
         pending "async block running on receiver"
         with_connected_sockets(example_port) do |subject, peer|
-          actor = ExampleActor.new
+          actor = with_wrapper_actor
+          allow(logger).to receive(:crash).with("Actor crashed!", IOError)
           begin
             actor.async.wrap { sleep 0.01; peer.close }
             expect do

data/spec/celluloid/io/udp_socket_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO::UDPSocket do
-  let(:payload) { 'ohai' }
+RSpec.describe Celluloid::IO::UDPSocket, library: :IO do
+  let(:payload) { "ohai" }
   let(:example_port) { assign_port }
   subject do
     Celluloid::IO::UDPSocket.new.tap do |sock|

data/spec/celluloid/io/unix_server_spec.rb

@@ -1,11 +1,10 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe Celluloid::IO::UNIXServer do
+RSpec.describe Celluloid::IO::UNIXServer, library: :IO do
   let(:example_port) { assign_port }
 
   describe "#accept" do
-
-    let(:payload) { 'ohai' }
+    let(:payload) { "ohai" }
 
     context "inside Celluloid::IO" do
       it "should be evented" do
@@ -15,7 +14,7 @@ describe Celluloid::IO::UNIXServer do
       end
 
       it "accepts a connection and returns a Celluloid::IO::UNIXSocket" do
-        pending if RUBY_PLATFORM == 'java'
+        pending if RUBY_PLATFORM == "java"
         with_unix_server do |subject|
           thread = Thread.new { UNIXSocket.new(example_unix_sock) }
           peer = within_io_actor { subject.accept }
@@ -30,9 +29,9 @@ describe Celluloid::IO::UNIXServer do
       it "raises if server already up" do
         with_unix_server do |subject|
           within_io_actor do
-            expect {
+            expect do
               Celluloid::IO::UNIXServer.open(example_unix_sock)
-            }.to raise_error(Errno::EADDRINUSE)
+            end.to raise_error(Errno::EADDRINUSE)
           end
         end
       end
@@ -58,12 +57,11 @@ describe Celluloid::IO::UNIXServer do
 
         it "raises if server already up" do
           with_unix_server do |subject|
-            expect {
+            expect do
               Celluloid::IO::UNIXServer.open(example_unix_sock)
-            }.to raise_error(Errno::EADDRINUSE)
+            end.to raise_error(Errno::EADDRINUSE)
           end
         end
-
       end
     end
   end