rubysl-socket 0.0.1 → 1.0.0

data/spec/option/int_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+ruby_version_is "1.9.2" do
+  describe "Socket::Option.int" do
+    it "creates a new Socket::Option for SO_LINGER" do
+      so = Socket::Option.int(:INET, :SOCKET, :KEEPALIVE, 5)
+      so.family.should == Socket::Constants::AF_INET
+      so.level.should == Socket::Constants::SOL_SOCKET
+      so.optname.should == Socket::Constants::SO_KEEPALIVE
+      so.data.should == [5].pack('i')
+    end
+  end
+
+  describe "Socket::Option#int" do
+    it "returns int option" do
+      so = Socket::Option.int(:INET, :SOCKET, :KEEPALIVE, 17)
+      so.int.should == 17
+
+      so = Socket::Option.int(:INET, :SOCKET, :KEEPALIVE, 32765)
+      so.int.should == 32765
+    end
+    it "raises TypeError if option has not good size" do
+      so = Socket::Option.new(:UNSPEC, :SOCKET, :KEEPALIVE, [0, 0].pack('i*'))
+      lambda { so.int }.should raise_error(TypeError)
+    end
+  end
+end

data/spec/option/linger_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+ruby_version_is "1.9.2" do
+  describe "Socket::Option.linger" do
+    it "creates a new Socket::Option for SO_LINGER" do
+      so = Socket::Option.linger(1, 10)
+      so.family.should == Socket::Constants::AF_UNSPEC
+      so.level.should == Socket::Constants::SOL_SOCKET
+      so.optname.should == Socket::Constants::SO_LINGER
+      so.data.should == [1, 10].pack('i*')
+    end
+    it "accepts boolean as onoff argument" do
+      so = Socket::Option.linger(false, 0)
+      so.data.should == [0, 0].pack('i*')
+
+      so = Socket::Option.linger(true, 1)
+      so.data.should == [1, 1].pack('i*')
+    end
+  end
+
+  describe "Socket::Option#linger" do
+    it "returns linger option" do
+      so = Socket::Option.linger(0, 5)
+      ary = so.linger
+      ary[0].should be_false
+      ary[1].should == 5
+
+      so = Socket::Option.linger(false, 4)
+      ary = so.linger
+      ary[0].should be_false
+      ary[1].should == 4
+
+      so = Socket::Option.linger(1, 10)
+      ary = so.linger
+      ary[0].should be_true
+      ary[1].should == 10
+
+      so = Socket::Option.linger(true, 9)
+      ary = so.linger
+      ary[0].should be_true
+      ary[1].should == 9
+    end
+    it "raises TypeError if not a SO_LINGER" do
+      so = Socket::Option.int(:AF_UNSPEC, :SOL_SOCKET, :KEEPALIVE, 1)
+      lambda { so.linger }.should raise_error(TypeError)
+    end
+    it "raises TypeError if option has not good size" do
+      so = Socket::Option.int(:AF_UNSPEC, :SOL_SOCKET, :LINGER, 1)
+      lambda { so.linger }.should raise_error(TypeError)
+    end
+  end
+end

data/spec/option/new_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+ruby_version_is "1.9.2" do
+  describe "Socket::Option.new" do
+    it "should accept integers" do
+      so = Socket::Option.new(Socket::AF_INET, Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, [0].pack('i'))
+      so.family.should == Socket::AF_INET
+      so.level.should == Socket::SOL_SOCKET
+      so.optname.should == Socket::SO_KEEPALIVE
+    end
+    it "should accept symbols" do
+      so = Socket::Option.new(:AF_INET, :SOL_SOCKET, :SO_KEEPALIVE, [0].pack('i'))
+      so.family.should == Socket::AF_INET
+      so.level.should == Socket::SOL_SOCKET
+      so.optname.should == Socket::SO_KEEPALIVE
+
+      so = Socket::Option.new(:INET, :SOCKET, :KEEPALIVE, [0].pack('i'))
+      so.family.should == Socket::AF_INET
+      so.level.should == Socket::SOL_SOCKET
+      so.optname.should == Socket::SO_KEEPALIVE
+    end
+    it "should raise error on unknown family" do
+      lambda { Socket::Option.new(:INET4, :SOCKET, :KEEPALIVE, [0].pack('i')) }.should raise_error(SocketError)
+    end
+    it "should raise error on unknown level" do
+      lambda { Socket::Option.new(:INET, :ROCKET, :KEEPALIVE, [0].pack('i')) }.should raise_error(SocketError)
+    end
+    it "should raise error on unknown option name" do
+      lambda { Socket::Option.new(:INET, :SOCKET, :ALIVE, [0].pack('i')) }.should raise_error(SocketError)
+    end
+  end
+end

data/spec/shared/pack_sockaddr.rb

@@ -0,0 +1,26 @@
+describe :socket_pack_sockaddr_in, :shared => true do
+  it "packs and unpacks" do
+    sockaddr_in = Socket.pack_sockaddr_in 0, nil
+    port, addr = Socket.unpack_sockaddr_in(sockaddr_in)
+    ["127.0.0.1", "::1"].include?(addr).should == true
+    port.should == 0
+
+    sockaddr_in = Socket.pack_sockaddr_in 0, ''
+    Socket.unpack_sockaddr_in(sockaddr_in).should == [0, '0.0.0.0']
+
+    sockaddr_in = Socket.pack_sockaddr_in 80, '127.0.0.1'
+    Socket.unpack_sockaddr_in(sockaddr_in).should == [80, '127.0.0.1']
+
+    sockaddr_in = Socket.pack_sockaddr_in '80', '127.0.0.1'
+    Socket.unpack_sockaddr_in(sockaddr_in).should == [80, '127.0.0.1']
+  end
+end
+
+describe :socket_pack_sockaddr_un, :shared => true do
+  not_supported_on :jruby, :windows do
+    it "packs and unpacks" do
+      sockaddr_un = Socket.pack_sockaddr_un '/tmp/s'
+      Socket.unpack_sockaddr_un(sockaddr_un).should == '/tmp/s'
+    end
+  end
+end

data/spec/shared/partially_closable_sockets.rb

@@ -0,0 +1,13 @@
+describe "partially closable sockets", :shared => true do
+  specify "if the write end is closed then the other side can read past EOF without blocking" do
+    @s1.write("foo")
+    @s1.close_write
+    @s2.read("foo".size + 1).should == "foo"
+  end
+
+  specify "closing the write end ensures that the other side can read until EOF" do
+    @s1.write("hello world")
+    @s1.close_write
+    @s2.read.should == "hello world"
+  end
+end

data/spec/shared/recv_nonblock.rb

@@ -0,0 +1,33 @@
+describe :socket_recv_nonblock, :shared => true do
+  not_supported_on :jruby do
+    before :each do
+      @s1 = Socket.new(Socket::AF_INET, Socket::SOCK_DGRAM, 0)
+      @s2 = Socket.new(Socket::AF_INET, Socket::SOCK_DGRAM, 0)
+    end
+
+    after :each do
+      @s1.close unless @s1.closed?
+      @s2.close unless @s2.closed?
+    end
+
+    it "raises EAGAIN if there's no data available" do
+      @s1.bind(Socket.pack_sockaddr_in(SocketSpecs.port, "127.0.0.1"))
+      lambda { @s1.recv_nonblock(5)}.should raise_error(Errno::EAGAIN)
+    end
+
+    it "receives data after it's ready" do
+      @s1.bind(Socket.pack_sockaddr_in(SocketSpecs.port, "127.0.0.1"))
+      @s2.send("aaa", 0, @s1.getsockname)
+      IO.select([@s1], nil, nil, 2)
+      @s1.recv_nonblock(5).should == "aaa"
+    end
+
+    it "does not block if there's no data available" do
+      @s1.bind(Socket.pack_sockaddr_in(SocketSpecs.port, "127.0.0.1"))
+      @s2.send("a", 0, @s1.getsockname)
+      IO.select([@s1], nil, nil, 2)
+      @s1.recv_nonblock(1).should == "a"
+      lambda { @s1.recv_nonblock(5)}.should raise_error(Errno::EAGAIN)
+    end
+  end
+end

data/spec/shared/socketpair.rb

@@ -0,0 +1,35 @@
+describe :socket_socketpair, :shared => true do
+  not_supported_on :jruby, :windows do
+    it "ensures the returned sockets are connected" do
+      s1, s2 = Socket.socketpair(Socket::AF_UNIX, 1, 0)
+      s1.puts("test")
+      s2.gets.should == "test\n"
+      s1.close
+      s2.close
+    end
+  end
+
+  it "only allows Socket constants as strings" do
+    [ :DGRAM, :RAW, :RDM, :SEQPACKET, :STREAM ].each do |socket_type|
+      lambda { Socket.socketpair(Socket::AF_UNIX, "SOCK_#{socket_type}", 0) }.should_not raise_error(SocketError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises SocketError if given symbol is not a Socket constants reference" do
+      lambda { Socket.socketpair(Socket::AF_UNIX, :NO_EXIST, 0) }.should raise_error(SocketError)
+    end
+
+    it "only allows Socket constants as symbols" do
+      [ :DGRAM, :RAW, :RDM, :SEQPACKET, :STREAM ].each do |socket_type|
+        lambda { Socket.socketpair(Socket::AF_UNIX, socket_type, 0) }.should_not raise_error(SocketError)
+      end
+    end
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "raises Errno::EPROTONOSUPPORT if socket type is not a String or Integer" do
+      lambda { Socket.socketpair(Socket::AF_UNIX, :DGRAM, 0) }.should raise_error(Errno::EPROTONOSUPPORT)
+    end
+  end
+end

data/spec/socket/accept_nonblock_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+require 'socket'
+
+describe "Socket#accept_nonblock" do
+  before :each do
+    @hostname = "127.0.0.1"
+    @addr = Socket.sockaddr_in(0, @hostname)
+    @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+    @socket.bind(@addr)
+    @socket.listen(1)
+  end
+
+  after :each do
+    @socket.close
+  end
+  
+  it "raises Errno::EAGAIN if the connection is not accepted yet" do
+    lambda { @socket.accept_nonblock }.should raise_error(Errno::EAGAIN)
+  end
+
+  ruby_version_is "1.9.2" do
+    it "raises IO::WaitReadable if the connection is not accepted yet" do
+      lambda { @socket.accept_nonblock }.should raise_error(IO::WaitReadable)
+    end
+  end
+end

data/spec/socket/accept_spec.rb

@@ -0,0 +1 @@
+require File.expand_path('../../fixtures/classes', __FILE__)

data/spec/socket/bind_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+include Socket::Constants
+
+describe "Socket#bind on SOCK_DGRAM socket" do
+  before :each do
+    @sock = Socket.new(AF_INET, SOCK_DGRAM, 0);
+    @sockaddr = Socket.pack_sockaddr_in(SocketSpecs.port, "127.0.0.1");
+  end
+
+  after :each do
+    @sock.closed?.should be_false
+    @sock.close
+  end
+
+  it "binds to a port" do
+    lambda { @sock.bind(@sockaddr) }.should_not raise_error
+  end
+
+  it "returns 0 if successful" do
+    @sock.bind(@sockaddr).should == 0
+  end
+
+  it "raises Errno::EINVAL when binding to an already bound port" do
+    @sock.bind(@sockaddr);
+
+    lambda { @sock.bind(@sockaddr); }.should raise_error(Errno::EINVAL);
+  end
+
+  it "raises Errno::EADDRNOTAVAIL when the specified sockaddr is not available from the local machine" do
+    sockaddr1 = Socket.pack_sockaddr_in(SocketSpecs.port, "4.3.2.1");
+    lambda { @sock.bind(sockaddr1); }.should raise_error(Errno::EADDRNOTAVAIL)
+  end
+
+  platform_is_not :os => [:windows, :cygwin] do
+    it "raises Errno::EACCES when the current user does not have permission to bind" do
+      sockaddr1 = Socket.pack_sockaddr_in(1, "127.0.0.1");
+      lambda { @sock.bind(sockaddr1); }.should raise_error(Errno::EACCES)
+    end
+  end
+end
+
+describe "Socket#bind on SOCK_STREAM socket" do
+  before :each do
+    @sock = Socket.new(AF_INET, SOCK_STREAM, 0);
+    @sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, true)
+    @sockaddr = Socket.pack_sockaddr_in(SocketSpecs.port, "127.0.0.1");
+  end
+
+  after :each do
+    @sock.closed?.should be_false
+    @sock.close
+  end
+
+  it "binds to a port" do
+    lambda { @sock.bind(@sockaddr) }.should_not raise_error
+  end
+
+  it "returns 0 if successful" do
+    @sock.bind(@sockaddr).should == 0
+  end
+
+  it "raises Errno::EINVAL when binding to an already bound port" do
+    @sock.bind(@sockaddr);
+
+    lambda { @sock.bind(@sockaddr); }.should raise_error(Errno::EINVAL);
+  end
+
+  it "raises Errno::EADDRNOTAVAIL when the specified sockaddr is not available from the local machine" do
+    sockaddr1 = Socket.pack_sockaddr_in(SocketSpecs.port, "4.3.2.1");
+    lambda { @sock.bind(sockaddr1); }.should raise_error(Errno::EADDRNOTAVAIL)
+  end
+
+  platform_is_not :os => [:windows, :cygwin] do
+    it "raises Errno::EACCES when the current user does not have permission to bind" do
+      sockaddr1 = Socket.pack_sockaddr_in(1, "127.0.0.1");
+      lambda { @sock.bind(sockaddr1); }.should raise_error(Errno::EACCES)
+    end
+  end
+end

data/spec/socket/connect_nonblock_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+require 'socket'
+
+describe "Socket#connect_nonblock" do
+  before :each do
+    @hostname = "127.0.0.1"
+    @addr = Socket.sockaddr_in(SocketSpecs.port, @hostname)
+    @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+    @thread = nil
+  end
+
+  after :each do
+    @socket.close
+    @thread.join if @thread
+  end
+
+  it "connects the socket to the remote side" do
+    ready = false
+    @thread = Thread.new do
+      server = TCPServer.new(@hostname, SocketSpecs.port)
+      ready = true
+      conn = server.accept
+      conn << "hello!"
+      conn.close
+      server.close
+    end
+
+    Thread.pass while (@thread.status and @thread.status != 'sleep') or !ready
+
+    begin
+      @socket.connect_nonblock(@addr)
+    rescue Errno::EINPROGRESS
+    end
+
+    IO.select nil, [@socket]
+
+    begin
+      @socket.connect_nonblock(@addr)
+    rescue Errno::EISCONN
+      # Not all OS's use this errno, so we trap and ignore it
+    end
+
+    @socket.read(6).should == "hello!"
+  end
+  
+  platform_is_not :freebsd do
+    it "raises Errno::EINPROGRESS when the connect would block" do
+      lambda do
+        @socket.connect_nonblock(@addr)
+      end.should raise_error(Errno::EINPROGRESS)
+    end
+
+    ruby_version_is "1.9.2" do
+      it "raises Errno::EINPROGRESS with IO::WaitWritable mixed in when the connect would block" do
+        lambda do
+          @socket.connect_nonblock(@addr)
+        end.should raise_error(IO::WaitWritable)
+      end
+    end
+  end
+end

data/spec/socket/connect_spec.rb

@@ -0,0 +1 @@
+require File.expand_path('../../fixtures/classes', __FILE__)

data/spec/socket/for_fd_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+require 'socket'
+
+describe "Socket.for_fd" do
+  before :each do
+    @server = TCPServer.new("127.0.0.1", SocketSpecs.port)
+    @client = TCPSocket.open("127.0.0.1", SocketSpecs.port)
+  end
+
+  after :each do
+    @socket.shutdown Socket::SHUT_RD if @socket
+    @client.shutdown Socket::SHUT_WR
+
+    @host.close if @host
+    @server.close
+  end
+
+  it "creates a new Socket that aliases the existing Socket's file descriptor" do
+    @socket = Socket.for_fd(@client.fileno)
+    @socket.fileno.should == @client.fileno
+
+    @socket.send("foo", 0)
+    @client.send("bar", 0)
+
+    @host = @server.accept
+    @host.read(3).should == "foo"
+    @host.read(3).should == "bar"
+  end
+end

data/spec/socket/getaddrinfo_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+require 'socket'
+
+describe "Socket#getaddrinfo" do
+  before :all do
+    @do_not_reverse_lookup = BasicSocket.do_not_reverse_lookup
+  end
+
+  before :each do
+    BasicSocket.do_not_reverse_lookup = true
+  end
+
+  after :each do
+    BasicSocket.do_not_reverse_lookup = false
+  end
+
+  after :all do
+    BasicSocket.do_not_reverse_lookup = @do_not_reverse_lookup
+  end
+
+  it "gets the address information" do
+    expected = []
+    # The check for AP_INET6's class is needed because ipaddr.rb adds
+    # fake AP_INET6 even in case when IPv6 is not really supported.
+    # Without such check, this test might fail when ipaddr was required
+    # by some other specs.
+    if (Socket.constants.include? 'AF_INET6') &&
+        (Socket::AF_INET6.class != Object) then
+      expected.concat [
+        ['AF_INET6', 80, SocketSpecs.hostname, '::1', Socket::AF_INET6,
+          Socket::SOCK_DGRAM, Socket::IPPROTO_UDP],
+        ['AF_INET6', 80, SocketSpecs.hostname, '::1', Socket::AF_INET6,
+          Socket::SOCK_STREAM, Socket::IPPROTO_TCP],
+        ['AF_INET6', 80, SocketSpecs.hostname, 'fe80::1%lo0', Socket::AF_INET6,
+          Socket::SOCK_DGRAM, Socket::IPPROTO_UDP],
+        ['AF_INET6', 80, SocketSpecs.hostname, 'fe80::1%lo0', Socket::AF_INET6,
+          Socket::SOCK_STREAM, Socket::IPPROTO_TCP],
+      ]
+    end
+
+    expected.concat [
+      ['AF_INET', 80, SocketSpecs.hostname, '127.0.0.1', Socket::AF_INET,
+        Socket::SOCK_DGRAM, Socket::IPPROTO_UDP],
+      ['AF_INET', 80, SocketSpecs.hostname, '127.0.0.1', Socket::AF_INET,
+        Socket::SOCK_STREAM, Socket::IPPROTO_TCP],
+    ]
+
+    addrinfo = Socket.getaddrinfo SocketSpecs.hostname, 'http'
+    addrinfo.each do |a|
+      case a.last
+      when Socket::IPPROTO_UDP, Socket::IPPROTO_TCP
+        expected.should include(a)
+      else
+        # don't check this. It's some weird protocol we don't know about
+        # so we can't spec it.
+      end
+    end
+  end
+
+   # #getaddrinfo will return a INADDR_ANY address (0.0.0.0
+   # or "::") if it's a passive socket. In the case of non-passive
+   # sockets (AI_PASSIVE not set) it should return the loopback
+   # address (127.0.0.1 or "::1".
+
+   it "accepts empty addresses for IPv4 passive sockets" do
+     res = Socket::getaddrinfo(nil, "http",
+                               Socket::AF_INET,
+                               Socket::SOCK_STREAM,
+                               Socket::IPPROTO_TCP,
+                               Socket::AI_PASSIVE)
+
+     expected = [["AF_INET", 80, "0.0.0.0", "0.0.0.0", Socket::AF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP],
+                 ["AF_INET", 80, "", "0.0.0.0", Socket::AF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP]]
+     res.each do |a|
+       expected.should include(a)
+     end
+   end
+
+   it "accepts empty addresses for IPv4 non-passive sockets" do
+     res = Socket::getaddrinfo(nil, "http",
+                               Socket::AF_INET,
+                               Socket::SOCK_STREAM,
+                               Socket::IPPROTO_TCP,
+                               0)
+
+     expected = [["AF_INET", 80, "127.0.0.1", "127.0.0.1", Socket::AF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP]]
+     res.should == expected
+   end
+
+
+   it "accepts empty addresses for IPv6 passive sockets" do
+     res = Socket::getaddrinfo(nil, "http",
+                               Socket::AF_INET6,
+                               Socket::SOCK_STREAM,
+                               Socket::IPPROTO_TCP,
+                               Socket::AI_PASSIVE)
+
+     expected = [
+       ["AF_INET6", 80, "::", "::", Socket::AF_INET6, Socket::SOCK_STREAM, Socket::IPPROTO_TCP],
+       ["AF_INET6", 80, "0:0:0:0:0:0:0:0", "0:0:0:0:0:0:0:0", Socket::AF_INET6, Socket::SOCK_STREAM, Socket::IPPROTO_TCP]
+     ]
+     res.each { |a| expected.should include (a) }
+   end
+
+   it "accepts empty addresses for IPv6 non-passive sockets" do
+     res = Socket::getaddrinfo(nil, "http",
+                               Socket::AF_INET6,
+                               Socket::SOCK_STREAM,
+                               Socket::IPPROTO_TCP,
+                               0)
+
+     expected = [
+       ["AF_INET6", 80, "::1", "::1", Socket::AF_INET6, Socket::SOCK_STREAM, Socket::IPPROTO_TCP],
+       ["AF_INET6", 80, "0:0:0:0:0:0:0:1", "0:0:0:0:0:0:0:1", Socket::AF_INET6, Socket::SOCK_STREAM, Socket::IPPROTO_TCP]
+     ]
+     res.each { |a| expected.should include (a) }
+   end
+end
+