rubysl-socket 0.0.1 → 1.0.0

data/spec/basicsocket/shutdown_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe "Socket::BasicSocket#shutdown" do
+
+end

data/spec/constants/constants_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+include Socket::Constants
+
+describe "Socket::Constants" do
+  it "defines socket types" do
+    consts = ["SOCK_DGRAM", "SOCK_RAW", "SOCK_RDM", "SOCK_SEQPACKET", "SOCK_STREAM"]
+    consts.each do |c|
+      Socket::Constants.should have_constant(c)
+    end
+  end
+
+  it "defines protocol families" do
+    consts = ["PF_INET6", "PF_INET", "PF_IPX", "PF_UNIX", "PF_UNSPEC"]
+    consts.each do |c|
+      Socket::Constants.should have_constant(c)
+    end
+  end
+
+  it "defines address families" do
+    consts = ["AF_INET6", "AF_INET", "AF_IPX", "AF_UNIX", "AF_UNSPEC"]
+    consts.each do |c|
+      Socket::Constants.should have_constant(c)
+    end
+  end
+
+  it "defines send/receive options" do
+    consts = ["MSG_DONTROUTE", "MSG_OOB", "MSG_PEEK"]
+    consts.each do |c|
+      Socket::Constants.should have_constant(c)
+    end
+  end
+
+  it "defines socket level options" do
+    consts = ["SOL_SOCKET"]
+    consts.each do |c|
+      Socket::Constants.should have_constant(c)
+    end
+  end
+
+  it "defines socket options" do
+    consts = ["SO_BROADCAST", "SO_DEBUG", "SO_DONTROUTE", "SO_ERROR", "SO_KEEPALIVE", "SO_LINGER",
+              "SO_OOBINLINE", "SO_RCVBUF", "SO_REUSEADDR", "SO_SNDBUF", "SO_TYPE"]
+    consts.each do |c|
+      Socket::Constants.should have_constant(c)
+    end
+
+  end
+
+  it "defines multicast options" do
+    consts = ["IP_ADD_MEMBERSHIP", "IP_DEFAULT_MULTICAST_LOOP", "IP_DEFAULT_MULTICAST_TTL",
+              "IP_MAX_MEMBERSHIPS", "IP_MULTICAST_LOOP", "IP_MULTICAST_TTL"]
+    consts.each do |c|
+      Socket::Constants.should have_constant(c)
+    end
+  end
+
+  it "defines TCP options" do
+    consts = ["TCP_MAXSEG", "TCP_NODELAY"]
+    consts.each do |c|
+      Socket::Constants.should have_constant(c)
+    end
+  end
+end

data/spec/fixtures/classes.rb

@@ -0,0 +1,174 @@
+require 'socket'
+
+module SocketSpecs
+  # helper to get the hostname associated to 127.0.0.1
+  def self.hostname
+    # Calculate each time, without caching, since the result might
+    # depend on things like do_not_reverse_lookup mode, which is
+    # changing from test to test
+    Socket.getaddrinfo("127.0.0.1", nil)[0][2]
+  end
+
+  def self.hostnamev6
+    Socket.getaddrinfo("::1", nil)[0][2]
+  end
+
+  def self.addr(which=:ipv4)
+    case which
+    when :ipv4
+      host = "127.0.0.1"
+    when :ipv6
+      host = "::1"
+    end
+    Socket.getaddrinfo(host, nil)[0][3]
+  end
+
+  def self.port
+    43191
+  end
+
+  def self.str_port
+    "43191"
+  end
+
+  def self.local_port
+    @base ||= $$
+    @base += 1
+    local_port = (@base % (0xffff-1024)) + 1024
+    local_port += 1 if local_port == port
+    local_port
+  end
+
+  def self.sockaddr_in(port, host)
+    Socket::SockAddr_In.new(Socket.sockaddr_in(port, host))
+  end
+
+  def self.socket_path
+    tmp("unix_server_spec.socket", false)
+  end
+
+  # TCPServer that does not block waiting for connections. Each
+  # connection is serviced in a separate thread. The data read
+  # from the socket is echoed back. The server is shutdown when
+  # the spec process exits.
+  class SpecTCPServer
+    @spec_server = nil
+
+    def self.start(host=nil, port=nil, logger=nil)
+      return if @spec_server
+
+      @spec_server = new host, port, logger
+      @spec_server.start
+
+      at_exit do
+        SocketSpecs::SpecTCPServer.shutdown
+      end
+    end
+
+    def self.get
+      @spec_server
+    end
+
+    # Clean up any waiting handlers.
+    def self.cleanup
+      @spec_server.cleanup if @spec_server
+    end
+
+    # Exit completely.
+    def self.shutdown
+      @spec_server.shutdown if @spec_server
+    end
+
+    attr_accessor :hostname, :port, :logger
+
+    def initialize(host=nil, port=nil, logger=nil)
+      @hostname = host || SocketSpecs.hostname
+      @port = port || SocketSpecs.port
+      @logger = logger
+      @cleanup = false
+      @shutdown = false
+      @accepted = false
+      @main = nil
+      @server = nil
+      @threads = []
+    end
+
+    def start
+      @main = Thread.new do
+        log "SpecTCPServer starting on #{@hostname}:#{@port}"
+        @server = TCPServer.new @hostname, @port
+
+        wait_for @server do
+          socket = @server.accept
+          log "SpecTCPServer accepted connection: #{socket}"
+          service socket
+
+          @accepted = true
+        end
+      end
+
+      Thread.pass until @server
+    end
+
+    def service(socket)
+      thr = Thread.new do
+        begin
+          wait_for socket do
+            break if cleanup?
+
+            data = socket.recv(1024)
+            break if data.empty?
+            log "SpecTCPServer received: #{data.inspect}"
+
+            break if data == "QUIT"
+
+            socket.send data, 0
+          end
+        ensure
+          socket.close unless socket.closed?
+        end
+      end
+
+      @threads << thr
+    end
+
+    def wait_for(io)
+      return unless io
+
+      loop do
+        read, _, _ = IO.select([io], [], [], 0.25)
+        return false if shutdown?
+        yield if read
+      end
+    end
+
+    def shutdown?
+      @shutdown
+    end
+
+    def cleanup?
+      @cleanup
+    end
+
+    def cleanup
+      @cleanup = true
+      log "SpecTCPServer cleaning up"
+
+      @threads.each { |thr| thr.join }
+      @cleanup = false
+    end
+
+    def shutdown
+      @shutdown = true
+      log "SpecTCPServer shutting down"
+
+      @threads.each { |thr| thr.join }
+      @main.join
+      @server.close if @accepted and !@server.closed?
+    end
+
+    def log(message)
+      @logger.puts message if @logger
+    end
+  end
+end

data/spec/fixtures/send_io.txt

@@ -0,0 +1 @@
+This data is magic.

data/spec/ipsocket/addr_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe "Socket::IPSocket#addr" do
+  before :all do
+    @do_not_reverse_lookup = BasicSocket.do_not_reverse_lookup
+  end
+
+
+  before :each do
+    @socket = TCPServer.new("127.0.0.1", SocketSpecs.port)
+  end
+
+  after :each do
+    @socket.close unless @socket.closed?
+    BasicSocket.do_not_reverse_lookup = false
+  end
+
+  after :all do
+    BasicSocket.do_not_reverse_lookup = @do_not_reverse_lookup
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "returns an array with the socket's information" do
+      BasicSocket.do_not_reverse_lookup = false
+
+      addrinfo = @socket.addr
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == SocketSpecs.hostname
+      addrinfo[3].should == "127.0.0.1"
+    end
+
+    it "returns an address in the array if do_not_reverse_lookup is true" do
+      BasicSocket.do_not_reverse_lookup = true
+      addrinfo = @socket.addr
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == "127.0.0.1"
+      addrinfo[3].should == "127.0.0.1"
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "returns an array with the socket's information" do
+      @socket.do_not_reverse_lookup = false
+      BasicSocket.do_not_reverse_lookup = false
+      addrinfo = @socket.addr
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == SocketSpecs.hostname
+      addrinfo[3].should == "127.0.0.1"
+    end
+
+    it "returns an address in the array if do_not_reverse_lookup is true" do
+      @socket.do_not_reverse_lookup = true
+      BasicSocket.do_not_reverse_lookup = true
+      addrinfo = @socket.addr
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == "127.0.0.1"
+      addrinfo[3].should == "127.0.0.1"
+    end
+    
+    it "returns an address in the array if passed false" do
+      addrinfo = @socket.addr(false)
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == "127.0.0.1"
+      addrinfo[3].should == "127.0.0.1"
+    end
+  end
+end

data/spec/ipsocket/getaddress_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe "Socket::IPSocket#getaddress" do
+
+  it "returns the IP address of hostname" do
+    addr_local = IPSocket.getaddress(SocketSpecs.hostname)
+    ["127.0.0.1", "::1"].include?(addr_local).should == true
+  end
+
+  it "returns the IP address when passed an IP" do
+    IPSocket.getaddress("127.0.0.1").should == "127.0.0.1"
+    IPSocket.getaddress("0.0.0.0").should == "0.0.0.0"
+  end
+
+  # There is no way to make this fail-proof on all machines, because
+  # DNS servers like opendns return A records for ANY host, including
+  # traditionally invalidly named ones.
+  quarantine! do
+    it "raises an error on unknown hostnames" do
+      lambda {
+        IPSocket.getaddress("rubyspecdoesntexist.fallingsnow.net")
+      }.should raise_error(SocketError)
+    end
+  end
+
+end

data/spec/ipsocket/peeraddr_spec.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe "Socket::IPSocket#peeraddr" do
+  before :all do
+    @do_not_reverse_lookup = BasicSocket.do_not_reverse_lookup
+  end
+
+  before :each do
+    @server = TCPServer.new("127.0.0.1", SocketSpecs.port)
+    @client = TCPSocket.new("127.0.0.1", SocketSpecs.port)
+  end
+
+  after :each do
+    @server.close unless @server.closed?
+    @client.close unless @client.closed?
+    BasicSocket.do_not_reverse_lookup = false
+  end
+
+  after :all do
+    BasicSocket.do_not_reverse_lookup = @do_not_reverse_lookup
+  end
+
+  it "raises error if socket is not connected" do
+    lambda { @server.peeraddr }.should raise_error
+  end
+
+
+  ruby_version_is ""..."1.9" do
+
+    it "returns an array of information on the peer" do
+      BasicSocket.do_not_reverse_lookup = false
+      addrinfo = @client.peeraddr
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == SocketSpecs.hostname
+      addrinfo[3].should == "127.0.0.1"
+    end
+
+    it "returns an IP instead of hostname if do_not_reverse_lookup is true" do
+      BasicSocket.do_not_reverse_lookup = true
+      addrinfo = @client.peeraddr
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == "127.0.0.1"
+      addrinfo[3].should == "127.0.0.1"
+    end
+  end
+
+  ruby_version_is "1.9" do
+
+    it "returns an array of information on the peer" do
+      @client.do_not_reverse_lookup = false
+      BasicSocket.do_not_reverse_lookup = false
+      addrinfo = @client.peeraddr
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == SocketSpecs.hostname
+      addrinfo[3].should == "127.0.0.1"
+    end
+
+    it "returns an IP instead of hostname if do_not_reverse_lookup is true" do
+      @client.do_not_reverse_lookup = true
+      BasicSocket.do_not_reverse_lookup = true
+      addrinfo = @client.peeraddr
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == "127.0.0.1"
+      addrinfo[3].should == "127.0.0.1"
+    end
+    
+    it "returns an IP instead of hostname if passed false" do
+      addrinfo = @client.peeraddr(false)
+      addrinfo[0].should == "AF_INET"
+      addrinfo[1].should == SocketSpecs.port
+      addrinfo[2].should == "127.0.0.1"
+      addrinfo[3].should == "127.0.0.1"
+    end
+  end
+end

data/spec/ipsocket/recvfrom_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe "Socket::IPSocket#recvfrom" do
+
+  before :each do
+    @server = TCPServer.new("127.0.0.1", SocketSpecs.port)
+    @client = TCPSocket.new("127.0.0.1", SocketSpecs.port)
+  end
+
+  after :each do
+    @server.close unless @server.closed?
+    @client.close unless @client.closed?
+  end
+
+  it "reads data from the connection" do
+    data = nil
+    t = Thread.new do
+      client = @server.accept
+      data = client.recvfrom(6)
+      client.close
+    end
+
+    @client.send('hello', 0)
+    @client.shutdown rescue nil
+    # shutdown may raise Errno::ENOTCONN when sent data is pending.
+    t.join
+
+    data.first.should == 'hello'
+  end
+
+  it "reads up to len bytes" do
+    data = nil
+    t = Thread.new do
+      client = @server.accept
+      data = client.recvfrom(3)
+      client.close
+    end
+
+    @client.send('hello', 0)
+    @client.shutdown rescue nil
+    t.join
+
+    data.first.should == 'hel'
+  end
+
+  it "returns an array with the data and connection info" do
+    data = nil
+    t = Thread.new do
+      client = @server.accept
+      data = client.recvfrom(3)
+      client.close
+    end
+
+    @client.send('hello', 0)
+    @client.shutdown rescue nil
+    t.join
+
+    data.size.should == 2
+    data.first.should == "hel"
+    # This does not apply to every platform, dependant on recvfrom(2)
+    # data.last.should == nil
+  end
+
+end