celluloid-io 0.16.2 → 0.16.5.pre0

data/spec/celluloid/io/tcp_server_spec.rb

@@ -11,7 +11,7 @@ describe Celluloid::IO::TCPServer do
     context "inside Celluloid::IO" do
       it "should be evented" do
         with_tcp_server do |subject|
-          within_io_actor { Celluloid::IO.evented? }.should be_true
+          expect(within_io_actor { Celluloid::IO.evented? }).to be_truthy
         end
       end
 
@@ -19,18 +19,18 @@ describe Celluloid::IO::TCPServer do
         with_tcp_server do |subject|
           thread = Thread.new { TCPSocket.new(example_addr, example_port) }
           peer = within_io_actor { subject.accept }
-          peer.should be_a Celluloid::IO::TCPSocket
+          expect(peer).to be_a Celluloid::IO::TCPSocket
 
           client = thread.value
           client.write payload
-          peer.read(payload.size).should eq payload
+          expect(peer.read(payload.size)).to eq payload
         end
       end
 
       context "outside Celluloid::IO" do
         it "should be blocking" do
           with_tcp_server do |subject|
-            Celluloid::IO.should_not be_evented
+            expect(Celluloid::IO).not_to be_evented
           end
         end
 
@@ -38,11 +38,11 @@ describe Celluloid::IO::TCPServer do
           with_tcp_server do |subject|
             thread = Thread.new { TCPSocket.new(example_addr, example_port) }
             peer   = subject.accept
-            peer.should be_a Celluloid::IO::TCPSocket
+            expect(peer).to be_a Celluloid::IO::TCPSocket
 
             client = thread.value
             client.write payload
-            peer.read(payload.size).should eq payload
+            expect(peer.read(payload.size)).to eq payload
           end
         end
       end

data/spec/celluloid/io/tcp_socket_spec.rb

@@ -11,7 +11,7 @@ describe Celluloid::IO::TCPSocket do
         thread = Thread.new { server.accept }
 
         socket = within_io_actor { Celluloid::IO::TCPSocket.open(example_addr, example_port) }
-        socket.should be_a(Celluloid::IO::TCPSocket)
+        expect(socket).to be_a(Celluloid::IO::TCPSocket)
 
         server.close
         thread.terminate
@@ -23,7 +23,7 @@ describe Celluloid::IO::TCPSocket do
           thread = Thread.new { server.accept }
   
           value = within_io_actor { Celluloid::IO::TCPSocket.open(example_addr, example_port) { true } }
-          value.should be_true
+          expect(value).to be_truthy
   
           server.close
           thread.terminate
@@ -38,7 +38,7 @@ describe Celluloid::IO::TCPSocket do
       peer = thread.value
 
       peer << payload
-      within_io_actor { socket.read(payload.size) }.should eq payload
+      expect(within_io_actor { socket.read(payload.size) }).to eq payload
 
       server.close
       socket.close
@@ -47,56 +47,56 @@ describe Celluloid::IO::TCPSocket do
 
     it "should be evented" do
       with_connected_sockets do |subject|
-        within_io_actor { Celluloid::IO.evented? }.should be_true
+        expect(within_io_actor { Celluloid::IO.evented? }).to be_truthy
       end
     end
 
     it "read complete payload when nil size is given to #read" do
       with_connected_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read(nil) }.should eq payload
+        expect(within_io_actor { subject.read(nil) }).to eq payload
       end
     end
 
     it "read complete payload when no size is given to #read" do
       with_connected_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read }.should eq payload
+        expect(within_io_actor { subject.read }).to eq payload
       end
     end
 
     it "reads data" do
       with_connected_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read(payload.size) }.should eq payload
+        expect(within_io_actor { subject.read(payload.size) }).to eq payload
       end
     end
 
     it "reads data in binary encoding" do
       with_connected_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read(payload.size).encoding }.should eq Encoding::BINARY
+        expect(within_io_actor { subject.read(payload.size).encoding }).to eq Encoding::BINARY
       end
     end
 
     it "reads partial data" do
       with_connected_sockets do |subject, peer|
         peer << payload * 2
-        within_io_actor { subject.readpartial(payload.size) }.should eq payload
+        expect(within_io_actor { subject.readpartial(payload.size) }).to eq payload
       end
     end
 
     it "reads partial data in binary encoding" do
       with_connected_sockets do |subject, peer|
         peer << payload * 2
-        within_io_actor { subject.readpartial(payload.size).encoding }.should eq Encoding::BINARY
+        expect(within_io_actor { subject.readpartial(payload.size).encoding }).to eq Encoding::BINARY
       end
     end
 
     it "writes data" do
       with_connected_sockets do |subject, peer|
         within_io_actor { subject << payload }
-        peer.read(payload.size).should eq payload
+        expect(peer.read(payload.size)).to eq payload
       end
     end
 
@@ -112,7 +112,7 @@ describe Celluloid::IO::TCPSocket do
           started_at = Time.now
           Thread.new{ sleep 0.5; peer.close; }
           within_io_actor { subject.eof? }
-          (Time.now - started_at).should > 0.5
+          expect(Time.now - started_at).to be > 0.5
         end
       end
       
@@ -124,7 +124,7 @@ describe Celluloid::IO::TCPSocket do
             within_io_actor {
               subject.read(1)
               Celluloid.timeout(0.5) {
-                subject.eof?.should be_false
+                expect(subject.eof?).to be_falsey
               }
             }
           }.to raise_error(Celluloid::Task::TimeoutError)
@@ -185,7 +185,7 @@ describe Celluloid::IO::TCPSocket do
       peer = thread.value
 
       peer << payload
-      socket.read(payload.size).should eq payload
+      expect(socket.read(payload.size)).to eq payload
 
       server.close
       socket.close
@@ -194,28 +194,28 @@ describe Celluloid::IO::TCPSocket do
 
     it "should be blocking" do
       with_connected_sockets do |subject|
-        Celluloid::IO.should_not be_evented
+        expect(Celluloid::IO).not_to be_evented
       end
     end
 
     it "reads data" do
       with_connected_sockets do |subject, peer|
         peer << payload
-        subject.read(payload.size).should eq payload
+        expect(subject.read(payload.size)).to eq payload
       end
     end
 
     it "reads partial data" do
       with_connected_sockets do |subject, peer|
         peer << payload * 2
-        subject.readpartial(payload.size).should eq payload
+        expect(subject.readpartial(payload.size)).to eq payload
       end
     end
 
     it "writes data" do
       with_connected_sockets do |subject, peer|
         subject << payload
-        peer.read(payload.size).should eq payload
+        expect(peer.read(payload.size)).to eq payload
       end
     end
   end

data/spec/celluloid/io/udp_socket_spec.rb

@@ -12,25 +12,25 @@ describe Celluloid::IO::UDPSocket do
 
   context "inside Celluloid::IO" do
     it "should be evented" do
-      within_io_actor { Celluloid::IO.evented? }.should be_true
+      expect(within_io_actor { Celluloid::IO.evented? }).to be_truthy
     end
 
     it "sends and receives packets" do
       within_io_actor do
         subject.send payload, 0, example_addr, example_port
-        subject.recvfrom(payload.size).first.should == payload
+        expect(subject.recvfrom(payload.size).first).to eq(payload)
       end
     end
   end
 
   context "outside Celluloid::IO" do
     it "should be blocking" do
-      Celluloid::IO.should_not be_evented
+      expect(Celluloid::IO).not_to be_evented
     end
 
     it "sends and receives packets" do
       subject.send payload, 0, example_addr, example_port
-      subject.recvfrom(payload.size).first.should == payload
+      expect(subject.recvfrom(payload.size).first).to eq(payload)
     end
   end
 end

data/spec/celluloid/io/unix_server_spec.rb

@@ -1,17 +1,22 @@
 require 'spec_helper'
 
 describe Celluloid::IO::UNIXServer do
-  describe "#accept" do
-    before do
-      pending "JRuby support" if defined?(JRUBY_VERSION)
+
+  if RUBY_PLATFORM == 'java'
+    before(:each) do
+      pending "jRuby support"
+      fail "Avoid potential deadlock under jRuby"
     end
+  end
+
+  describe "#accept" do
 
     let(:payload) { 'ohai' }
 
     context "inside Celluloid::IO" do
       it "should be evented" do
         with_unix_server do |subject|
-          within_io_actor { Celluloid::IO.evented? }.should be_true
+          expect(within_io_actor { Celluloid::IO.evented? }).to be_truthy
         end
       end
 
@@ -19,11 +24,11 @@ describe Celluloid::IO::UNIXServer do
         with_unix_server do |subject|
           thread = Thread.new { UNIXSocket.new(example_unix_sock) }
           peer = within_io_actor { subject.accept }
-          peer.should be_a Celluloid::IO::UNIXSocket
+          expect(peer).to be_a Celluloid::IO::UNIXSocket
 
           client = thread.value
           client.write payload
-          peer.read(payload.size).should eq payload
+          expect(peer.read(payload.size)).to eq payload
         end
       end
 
@@ -40,7 +45,7 @@ describe Celluloid::IO::UNIXServer do
       context "outside Celluloid::IO" do
         it "should be blocking" do
           with_unix_server do |subject|
-            Celluloid::IO.should_not be_evented
+            expect(Celluloid::IO).not_to be_evented
           end
         end
 
@@ -48,11 +53,11 @@ describe Celluloid::IO::UNIXServer do
           with_unix_server do |subject|
             thread = Thread.new { UNIXSocket.new(example_unix_sock) }
             peer   = subject.accept
-            peer.should be_a Celluloid::IO::UNIXSocket
+            expect(peer).to be_a Celluloid::IO::UNIXSocket
 
             client = thread.value
             client.write payload
-            peer.read(payload.size).should eq payload
+            expect(peer.read(payload.size)).to eq payload
           end
         end
 

data/spec/celluloid/io/unix_socket_spec.rb

@@ -1,8 +1,12 @@
 require 'spec_helper'
 
 describe Celluloid::IO::UNIXSocket do
-  before do
-    pending "JRuby support" if defined?(JRUBY_VERSION)
+  
+  if RUBY_PLATFORM == 'java'
+    before(:each) do
+      pending "jRuby support"
+      fail "Avoid potential deadlock under jRuby"
+    end
   end
 
   let(:payload) { 'ohai' }
@@ -15,7 +19,7 @@ describe Celluloid::IO::UNIXSocket do
       peer = thread.value
 
       peer << payload
-      within_io_actor { socket.read(payload.size) }.should eq payload
+      expect(within_io_actor { socket.read(payload.size) }).to eq payload
 
       server.close
       socket.close
@@ -25,56 +29,56 @@ describe Celluloid::IO::UNIXSocket do
 
     it "should be evented" do
       with_connected_unix_sockets do |subject|
-        within_io_actor { Celluloid::IO.evented? }.should be_true
+        expect(within_io_actor { Celluloid::IO.evented? }).to be_truthy
       end
     end
 
     it "read complete payload when nil size is given to #read" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read(nil) }.should eq payload
+        expect(within_io_actor { subject.read(nil) }).to eq payload
       end
     end
 
     it "read complete payload when no size is given to #read" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read }.should eq payload
+        expect(within_io_actor { subject.read }).to eq payload
       end
     end
 
     it "reads data" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read(payload.size) }.should eq payload
+        expect(within_io_actor { subject.read(payload.size) }).to eq payload
       end
     end
 
     it "reads data in binary encoding" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload
-        within_io_actor { subject.read(payload.size).encoding }.should eq Encoding::BINARY
+        expect(within_io_actor { subject.read(payload.size).encoding }).to eq Encoding::BINARY
       end
     end
 
     it "reads partial data" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload * 2
-        within_io_actor { subject.readpartial(payload.size) }.should eq payload
+        expect(within_io_actor { subject.readpartial(payload.size) }).to eq payload
       end
     end
 
     it "reads partial data in binary encoding" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload * 2
-        within_io_actor { subject.readpartial(payload.size).encoding }.should eq Encoding::BINARY
+        expect(within_io_actor { subject.readpartial(payload.size).encoding }).to eq Encoding::BINARY
       end
     end
 
     it "writes data" do
       with_connected_unix_sockets do |subject, peer|
         within_io_actor { subject << payload }
-        peer.read(payload.size).should eq payload
+        expect(peer.read(payload.size)).to eq payload
       end
     end
 
@@ -99,7 +103,7 @@ describe Celluloid::IO::UNIXSocket do
           started_at = Time.now
           Thread.new{ sleep 0.5; peer.close; }
           within_io_actor { subject.eof? }
-          (Time.now - started_at).should > 0.5
+          expect(Time.now - started_at).to be > 0.5
         end
       end
       
@@ -111,7 +115,7 @@ describe Celluloid::IO::UNIXSocket do
             within_io_actor {
               subject.read(1)
               Celluloid.timeout(0.5) {
-                subject.eof?.should be_false
+                expect(subject.eof?).to be_falsey
               }
             }
           }.to raise_error(Celluloid::Task::TimeoutError)
@@ -128,7 +132,7 @@ describe Celluloid::IO::UNIXSocket do
       peer = thread.value
 
       peer << payload
-      socket.read(payload.size).should eq payload
+      expect(socket.read(payload.size)).to eq payload
 
       server.close
       socket.close
@@ -138,28 +142,28 @@ describe Celluloid::IO::UNIXSocket do
 
     it "should be blocking" do
       with_connected_unix_sockets do |subject|
-        Celluloid::IO.should_not be_evented
+        expect(Celluloid::IO).not_to be_evented
       end
     end
 
     it "reads data" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload
-        subject.read(payload.size).should eq payload
+        expect(subject.read(payload.size)).to eq payload
       end
     end
 
     it "reads partial data" do
       with_connected_unix_sockets do |subject, peer|
         peer << payload * 2
-        subject.readpartial(payload.size).should eq payload
+        expect(subject.readpartial(payload.size)).to eq payload
       end
     end
 
     it "writes data" do
       with_connected_unix_sockets do |subject, peer|
         subject << payload
-        peer.read(payload.size).should eq payload
+        expect(peer.read(payload.size)).to eq payload
       end
     end
   end

data/spec/spec_helper.rb

@@ -35,7 +35,7 @@ class ExampleActor
   end
 end
 
-EXAMPLE_PORT = 12345
+EXAMPLE_PORT = 12345 + Random.rand(1024)
 
 def example_addr; '127.0.0.1'; end
 def example_port; EXAMPLE_PORT; end
@@ -72,8 +72,7 @@ end
 
 def with_connected_sockets
   with_tcp_server do |server|
-    # FIXME: client isn't actually a Celluloid::IO::TCPSocket yet
-    client = ::TCPSocket.new(example_addr, example_port)
+    client = Celluloid::IO::TCPSocket.new(example_addr, example_port)
     peer = server.accept
 
     begin