cool.io 1.0.0 → 1.9.0

data/spec/tcp_server_spec.rb

@@ -0,0 +1,225 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+TIMEOUT = 0.010
+HOST = '127.0.0.1'
+PORT = unused_port
+
+def send_data(data)
+  io = TCPSocket.new('127.0.0.1', PORT)
+  begin
+    io.write data
+  ensure
+    io.close
+  end
+end
+
+class MyConnection < Coolio::Socket
+  attr_accessor :data, :connected, :closed
+
+  def initialize(io, on_message)
+    super(io)
+    @on_message = on_message
+  end
+
+  def on_connect
+    @connected = true
+  end
+
+  def on_close
+    @closed = true
+  end
+
+  def on_read(data)
+    @on_message.call(data)
+  end
+end
+
+@data = ""
+def on_message(data)
+  @data = data
+end
+
+def test_run(data = nil)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  thread = Thread.new { reactor.run }
+  send_data(data) if data
+  sleep TIMEOUT
+  reactor.stop
+  server.detach
+  send_data('') # to leave from blocking loop
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+def test_run_once(data = nil)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  thread = Thread.new do
+    reactor.run_once # on_connect
+    reactor.run_once # on_read
+  end
+  send_data(data) if data
+  thread.join
+  server.detach
+  @data
+ensure
+  server.close
+end
+
+def test_run_once_timeout(timeout = TIMEOUT)
+  @data = ""
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  thread = Thread.new { reactor.run_once(timeout) }
+  sleep timeout
+  server.detach
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+def test_run_timeout(data = nil, timeout = TIMEOUT)
+  reactor = Coolio::Loop.new
+  server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
+  reactor.attach(server)
+  running = true
+  thread = Thread.new do
+    while running and reactor.has_active_watchers?
+      reactor.run_once(timeout)
+    end
+  end
+  send_data(data) if data
+  sleep timeout
+  server.detach
+  running = false # another send is not required
+  thread.join
+  @data
+ensure
+  server.close
+end
+
+# This test should work on Windows
+describe Coolio::TCPServer do
+
+  it '#run' do
+    expect(test_run("hello")).to eq("hello")
+  end
+
+  it '#run_once' do
+    expect(test_run_once("hello")).to eq("hello")
+  end
+
+  it '#run_once(timeout)' do
+    test_run_once_timeout # should not block
+  end
+
+  it '#run_once(-timeout)' do
+    expect { test_run_once_timeout(-0.1) }.to raise_error(ArgumentError)
+  end
+
+  it '#run(timeout)' do
+    expect(test_run_timeout("hello")).to eq("hello")
+  end
+
+  describe "functionaltest" do
+    let :loop do
+      Coolio::Loop.new
+    end
+    
+    let :port do
+      unused_port
+    end
+    
+    context "#on_connect" do
+      class ServerOnConnect < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_connect
+          @cb.call
+        end
+      end
+      
+      it "connected socket called on_connect" do
+        begin
+          connected = false
+          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { connected = true })
+          loop.attach server
+          s = TCPSocket.open("localhost", port)
+          loop.run_once
+          s.close
+          expect(connected).to eq true
+        ensure
+          server.detach
+        end
+      end
+    end
+    
+    context "#on_close" do
+      class ServerOnClose < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_close
+          @cb.call
+        end
+      end
+      
+      it "closed socket called on_close" do
+        begin
+          closed = false
+          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { closed = true })
+          loop.attach server
+          s = TCPSocket.open("localhost", port)
+          loop.run_once
+          s.close
+          loop.run_once
+          expect(closed).to eq true
+        ensure
+          server.detach
+        end
+      end
+    end
+    
+    context "#on_read" do
+      class Echo < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_read(data)
+          @cb.call data
+          _size = write(data + "fff")
+        end
+      end
+      
+      it "server socket received data" do
+        begin
+          data = "aaa"
+          server = Cool.io::TCPServer.new("localhost", port, Echo, proc { |d| data = d })
+          loop.attach server
+          thread = Thread.new { loop.run }
+          s = TCPSocket.open("localhost", port)
+          s.write "zzz"
+          sleep 0.1
+          expect(data).to eq "zzz"
+          expect(s.read 6).to eq "zzzfff"
+        ensure
+          s.close
+          loop.stop
+          server.detach
+          thread.join
+        end
+      end
+    end
+  end
+end

data/spec/tcp_socket_spec.rb

@@ -0,0 +1,185 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Coolio::TCPSocket do
+  let :loop do
+    Coolio::Loop.new
+  end
+  
+  before :each do
+    @echo = TCPServer.new("127.0.0.1", 0)
+    @host = @echo.addr[3]
+    @port = @echo.addr[1]
+    @running = true
+    @echo_thread = Thread.new do
+      socks = [@echo]
+      begin
+        serv socks
+      ensure
+        socks.each do |s|
+          s.close
+        end
+      end
+      Thread.pass
+    end
+  end
+  
+  def serv(socks)
+    while @running
+      selected = select(socks, [], [], 0.1)
+      next if selected.nil?
+      selected[0].each do |s|
+        if s == @echo
+          socks.push s.accept
+          next
+        end
+        begin
+          unless s.eof?
+            s.write(s.read_nonblock 1)
+          end
+        rescue SystemCallError, EOFError, IOError, SocketError
+        end
+      end
+    end
+  end
+  
+  def shutdown
+    if @running
+      @running = false
+      @echo_thread.join
+    end
+  end
+  
+  after :each do
+    shutdown
+  end
+
+  context "#close" do
+    it "detaches all watchers on #close before loop#run" do
+      client = Coolio::TCPSocket.connect(@host, @port)
+      loop.attach client
+      client.close
+      expect(loop.watchers.size).to eq 0
+    end
+  end
+
+  context "#on_connect" do
+    class OnConnect < Cool.io::TCPSocket
+      attr :connected
+      def on_connect
+        @connected = true
+      end
+    end
+    
+    it "connected client called on_connect" do
+      begin
+        c = OnConnect.connect(@host, @port)
+        loop.attach c
+        loop.run_once
+        expect(c.connected).to eq true
+      ensure
+        c.close
+      end
+    end
+  end
+
+  context "#on_connect_failed" do
+    class OnConnectFailed < Cool.io::TCPSocket
+      attr :connect_failed
+      def on_connect_failed
+        @connect_failed = true
+      end
+    end
+    
+    it "try to connect dead host" do
+      serv = TCPServer.new(0)
+      dead_host = serv.addr[3]
+      dead_port = serv.addr[1]
+      serv.close
+      
+      c = OnConnectFailed.connect(dead_host, dead_port)
+      loop.attach c
+      loop.run_once # on_connect_failed
+      expect(c.connect_failed).to eq true
+    end
+  end
+
+  context "#on_close" do
+    class Closed < StandardError; end
+    class OnClose < Cool.io::TCPSocket
+      def on_close
+        raise Closed
+      end
+    end
+    
+    let :client do
+      OnClose.connect(@host, @port)
+    end
+    
+    before :each do
+      loop.attach client
+      loop.run_once # on_connect
+      client.write "0"
+    end
+    
+    it "disconnect from client" do
+      expect { client.close }.to raise_error(Closed)
+    end
+
+    it "disconnect from server" do
+      shutdown
+      expect { loop.run }.to raise_error(Closed)
+    end
+  end
+  
+  context "#on_read" do
+    class Finished < StandardError; end
+    class OnRead < Cool.io::TCPSocket
+      attr :read_data, :times
+      def on_connect
+        @read_data = ""
+        @times = 0
+      end
+      def on_read(data)
+        @read_data += data
+        @times += 1
+        if @times < 5
+          write "#{@times}"
+        else
+          close
+          raise Finished
+        end
+      end
+    end
+    
+    it "receive 5 times" do
+      c = OnRead.connect(@host, @port)
+      loop.attach c
+      loop.run_once # on_connect
+      c.write "0"
+      expect { loop.run }.to raise_error(Finished)
+      
+      expect(c.times).to eq 5
+      expect(c.read_data).to eq "01234"
+    end
+  end
+  
+  context "#on_write_complete" do
+    class WriteComplete < StandardError; end
+    class OnWriteComplete < Cool.io::TCPSocket
+      attr :called
+      def on_write_complete
+        @called = true
+        close
+        raise WriteComplete
+      end
+    end
+    
+    it "on_write_complete is called" do
+      c = OnWriteComplete.connect(@host, @port)
+      loop.attach c
+      loop.run_once # on_connect
+      c.write "aaa"
+      expect { loop.run }.to raise_error(WriteComplete)
+    end
+  end
+end

data/spec/timer_watcher_spec.rb

@@ -4,15 +4,19 @@ describe Cool.io::TimerWatcher do
 
   interval = 0.010
 
+  let :loop do
+    Cool.io::Loop.new
+  end
+
   it "can have the on_timer callback defined after creation" do
     @watcher = Cool.io::TimerWatcher.new(interval, true)
     nr = '0'
-    @watcher.on_timer { nr.succ! }.should == nil
-    @watcher.attach(Cool.io::Loop.default).should == @watcher
-    nr.should == '0'
+    expect(@watcher.on_timer { nr.succ! }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('0')
     sleep interval
-    Cool.io::Loop.default.run_once
-    nr.should == '1'
+    loop.run_once
+    expect(nr).to eq('1')
   end
 
   it "can be subclassed" do
@@ -24,29 +28,29 @@ describe Cool.io::TimerWatcher do
       end
     end
     @watcher = MyTimerWatcher.new(interval, true)
-    @watcher.attach(Cool.io::Loop.default).should == @watcher
-    MyTimerWatcher::TMP.should == '0'
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(MyTimerWatcher::TMP).to eq('0')
     sleep interval
-    Cool.io::Loop.default.run_once
-    MyTimerWatcher::TMP.should == '1'
+    loop.run_once
+    expect(MyTimerWatcher::TMP).to eq('1')
   end
 
   it "can have the on_timer callback redefined between runs" do
     @watcher = Cool.io::TimerWatcher.new(interval, true)
     nr = '0'
-    @watcher.on_timer { nr.succ! }.should == nil
-    @watcher.attach(Cool.io::Loop.default).should == @watcher
-    nr.should == '0'
+    expect(@watcher.on_timer { nr.succ! }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('0')
     sleep interval
-    Cool.io::Loop.default.run_once
-    nr.should == '1'
+    loop.run_once
+    expect(nr).to eq('1')
     @watcher.detach
-    @watcher.on_timer { nr = :foo }.should == nil
-    @watcher.attach(Cool.io::Loop.default).should == @watcher
-    nr.should == '1'
+    expect(@watcher.on_timer { nr = :foo }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('1')
     sleep interval
-    Cool.io::Loop.default.run_once
-    nr.should == :foo
+    loop.run_once
+    expect(nr).to eq(:foo)
   end
 
   after :each do

data/spec/udp_socket_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "Coolio::UDPSocket" do
+  let :loop do
+    Coolio::Loop.new
+  end
+  
+  before :each do
+    @echo = UDPSocket.open
+    @echo.bind nil, 0
+    @port = @echo.addr[1]
+    
+    @running = true
+    @echo_thread = Thread.new do
+      while @running
+        begin
+          msg, sender = @echo.recvfrom_nonblock(3)
+          @echo.send(msg + "bbb", 0, sender[3], sender[1])
+        rescue IO::WaitReadable
+        end
+        Thread.pass
+      end
+    end
+  end
+  
+  after :each do
+    @running = false
+    @echo_thread.join
+    @echo.close
+  end
+  
+  class Readable < Cool.io::IOWatcher
+    attr :socket, :received
+    def initialize
+      @socket = UDPSocket.new
+      super(@socket)
+    end
+    
+    def on_readable
+      @received = @socket.recvfrom_nonblock(6).first
+    end
+  end
+  
+  it "receive message #on_readable 5 times" do
+    5.times do
+      begin
+        r = Readable.new
+        r.socket.send "aaa", 0, "localhost", @port
+        
+        loop.attach r
+        loop.run_once
+        expect(r.received).to eq "aaabbb"
+      ensure
+        r.detach
+      end
+    end
+  end
+end

data/spec/unix_listener_spec.rb

@@ -1,25 +1,25 @@
 require File.expand_path('../spec_helper', __FILE__)
 require 'tempfile'
 
-describe Cool.io::UNIXListener do
+describe Cool.io::UNIXListener, :env => :exclude_win do
 
   before :each do
     @tmp = Tempfile.new('coolio_unix_listener_spec')
-    File.unlink(@tmp.path).should == 1
-    File.exist?(@tmp.path).should == false
+    expect(File.unlink(@tmp.path)).to eq(1)
+    expect(File.exist?(@tmp.path)).to eq(false)
   end
 
   it "creates a new UNIXListener" do
-    listener = Cool.io::UNIXListener.new(@tmp.path)
-    File.socket?(@tmp.path).should == true
+    _listener = Cool.io::UNIXListener.new(@tmp.path)
+    expect(File.socket?(@tmp.path)).to eq(true)
   end
 
   it "builds off an existing UNIXServer" do
     unix_server = UNIXServer.new(@tmp.path)
-    File.socket?(@tmp.path).should == true
+    expect(File.socket?(@tmp.path)).to eq(true)
     listener = Cool.io::UNIXListener.new(unix_server)
-    File.socket?(@tmp.path).should == true
-    listener.fileno.should == unix_server.fileno
+    expect(File.socket?(@tmp.path)).to eq(true)
+    expect(listener.fileno).to eq(unix_server.fileno)
   end
 
 end

data/spec/unix_server_spec.rb

@@ -1,25 +1,27 @@
 require File.expand_path('../spec_helper', __FILE__)
 require 'tempfile'
 
-describe Cool.io::UNIXServer do
+describe Cool.io::UNIXServer, :env => :exclude_win do
 
   before :each do
     @tmp = Tempfile.new('coolio_unix_server_spec')
-    File.unlink(@tmp.path).should == 1
-    File.exist?(@tmp.path).should == false
+    expect(File.unlink(@tmp.path)).to eq(1)
+    expect(File.exist?(@tmp.path)).to eq(false)
   end
 
   it "creates a new Cool.io::UNIXServer" do
     listener = Cool.io::UNIXListener.new(@tmp.path)
-    File.socket?(@tmp.path).should == true
+    listener.listen(24)
+    expect(File.socket?(@tmp.path)).to eq(true)
   end
 
   it "builds off an existing ::UNIXServer" do
     unix_server = ::UNIXServer.new(@tmp.path)
-    File.socket?(@tmp.path).should == true
-    listener = Cool.io::UNIXServer.new(unix_server)
-    File.socket?(@tmp.path).should == true
-    listener.fileno.should == unix_server.fileno
+    expect(File.socket?(@tmp.path)).to eq(true)
+    listener = Cool.io::UNIXServer.new(unix_server, Coolio::UNIXSocket)
+    listener.listen(24)
+    expect(File.socket?(@tmp.path)).to eq(true)
+    expect(listener.fileno).to eq(unix_server.fileno)
   end
 
 end