thrift 0.22.0 → 0.24.0

data/spec/recursion_depth_spec.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+require 'spec_helper'
+
+# Round-trip test for struct/union/exception recursion depth, driving the
+# *generated* read/write path (Thrift::Struct#read/#write,
+# Thrift::Union#read/#write) over RecTree / RecUnion / RecError from
+# ThriftSpec.thrift; a linear chain is one struct level deeper per node, so a
+# chain of N nodes reaches depth N.
+#
+# NOTE: the Ruby library does not enforce a recursion-depth limit yet
+# (THRIFT-6045). The round-trip / within-limit examples are active; the
+# limit-enforcement (over-limit) examples are `pending` and will start passing
+# once the limit is implemented, at which point RSpec flags them to be enabled.
+describe 'recursion depth limit' do
+  # The intended struct/union nesting limit. The Ruby library does not enforce a
+  # recursion-depth limit yet (THRIFT-6045); the limit-enforcement examples below
+  # are therefore `pending` until it is implemented. 64 matches the limit other
+  # Thrift libraries use.
+  RECURSION_LIMIT = 64
+
+  # Attached to the pending (over-limit) examples.
+  PENDING_REASON = 'recursion-depth limit not implemented in the Ruby library yet (THRIFT-6045)'
+
+  def binary_protocol
+    Thrift::BinaryProtocol.new(Thrift::MemoryBufferTransport.new)
+  end
+
+  # A linearly nested RecTree that is `depth` struct levels deep.
+  def struct_chain(depth)
+    node = SpecNamespace::RecTree.new(item: depth, children: [])
+    node.children = [struct_chain(depth - 1)] if depth > 1
+    node
+  end
+
+  def tree_depth(node)
+    n = 0
+    until node.nil?
+      n += 1
+      break if node.children.nil? || node.children.empty?
+      node = node.children.first
+    end
+    n
+  end
+
+  # A linearly nested RecUnion that is `depth` levels deep (each union holds the
+  # next; the innermost holds a scalar leaf).
+  def union_chain(depth)
+    if depth > 1
+      SpecNamespace::RecUnion.new(children: [union_chain(depth - 1)])
+    else
+      SpecNamespace::RecUnion.new(leaf: 0)
+    end
+  end
+
+  # A linearly nested RecError exception that is `depth` struct levels deep.
+  # Exceptions read/write through the same generated path as structs, so
+  # tree_depth applies to the decoded chain too.
+  def error_chain(depth)
+    node = SpecNamespace::RecError.new(leaf: depth, children: [])
+    node.children = [error_chain(depth - 1)] if depth > 1
+    node
+  end
+
+  # Emit, via raw protocol calls (which carry no depth guard), the wire image of
+  # a RecTree chain `depth` levels deep. This lets the read tests feed an
+  # over-limit payload that the guarded writer would itself refuse to produce.
+  def write_raw_tree(oprot, depth)
+    oprot.write_struct_begin('RecTree')
+    oprot.write_field_begin('children', Thrift::Types::LIST, 1)
+    oprot.write_list_begin(Thrift::Types::STRUCT, depth > 1 ? 1 : 0)
+    write_raw_tree(oprot, depth - 1) if depth > 1
+    oprot.write_list_end
+    oprot.write_field_end
+    oprot.write_field_begin('item', Thrift::Types::I16, 2)
+    oprot.write_i16(depth)
+    oprot.write_field_end
+    oprot.write_field_stop
+    oprot.write_struct_end
+  end
+
+  # Same as write_raw_tree but for the RecError exception (leaf is i32 here).
+  def write_raw_error(oprot, depth)
+    oprot.write_struct_begin('RecError')
+    oprot.write_field_begin('children', Thrift::Types::LIST, 1)
+    oprot.write_list_begin(Thrift::Types::STRUCT, depth > 1 ? 1 : 0)
+    write_raw_error(oprot, depth - 1) if depth > 1
+    oprot.write_list_end
+    oprot.write_field_end
+    oprot.write_field_begin('leaf', Thrift::Types::I32, 2)
+    oprot.write_i32(depth)
+    oprot.write_field_end
+    oprot.write_field_stop
+    oprot.write_struct_end
+  end
+
+  def expect_depth_limit
+    expect { yield }.to raise_error(Thrift::ProtocolException) { |e|
+      expect(e.type).to eq(Thrift::ProtocolException::DEPTH_LIMIT)
+    }
+  end
+
+  describe 'structs' do
+    it 'round-trips a chain at the limit' do
+      prot = binary_protocol
+      struct_chain(RECURSION_LIMIT).write(prot)
+      result = SpecNamespace::RecTree.new
+      result.read(prot)
+      expect(tree_depth(result)).to eq(RECURSION_LIMIT)
+    end
+
+    it 'rejects writing a chain past the limit' do
+      pending PENDING_REASON
+      expect_depth_limit { struct_chain(RECURSION_LIMIT + 1).write(binary_protocol) }
+    end
+
+    it 'rejects reading a payload past the limit' do
+      pending PENDING_REASON
+      prot = binary_protocol
+      write_raw_tree(prot, RECURSION_LIMIT + 1)
+      expect_depth_limit { SpecNamespace::RecTree.new.read(prot) }
+    end
+
+    it 'round-trips a wide shallow tree (counter unwinds per sibling)' do
+      width = RECURSION_LIMIT * 3
+      prot = binary_protocol
+      root = SpecNamespace::RecTree.new(
+        item: 0,
+        children: (1..width).map { |i| SpecNamespace::RecTree.new(item: i, children: []) }
+      )
+      root.write(prot)
+      result = SpecNamespace::RecTree.new
+      result.read(prot)
+      expect(result.children.size).to eq(width)
+    end
+  end
+
+  describe 'unions' do
+    it 'round-trips a chain at the limit' do
+      prot = binary_protocol
+      union_chain(RECURSION_LIMIT).write(prot)
+      expect { SpecNamespace::RecUnion.new.read(prot) }.not_to raise_error
+    end
+
+    it 'rejects writing a chain past the limit' do
+      pending PENDING_REASON
+      expect_depth_limit { union_chain(RECURSION_LIMIT + 1).write(binary_protocol) }
+    end
+  end
+
+  describe 'exceptions' do
+    it 'round-trips a chain at the limit' do
+      prot = binary_protocol
+      error_chain(RECURSION_LIMIT).write(prot)
+      result = SpecNamespace::RecError.new
+      result.read(prot)
+      expect(tree_depth(result)).to eq(RECURSION_LIMIT)
+    end
+
+    it 'rejects writing a chain past the limit' do
+      pending PENDING_REASON
+      expect_depth_limit { error_chain(RECURSION_LIMIT + 1).write(binary_protocol) }
+    end
+
+    it 'rejects reading a payload past the limit' do
+      pending PENDING_REASON
+      prot = binary_protocol
+      write_raw_error(prot, RECURSION_LIMIT + 1)
+      expect_depth_limit { SpecNamespace::RecError.new.read(prot) }
+    end
+  end
+
+  describe 'protocol decorators' do
+    # A struct written through a decorator must still be bounded and must not
+    # crash: decorators (MultiplexedProtocol via ProtocolDecorator) do not chain
+    # BaseProtocol#initialize, so the depth counter starts unset on that object.
+    it 'round-trips a struct through a MultiplexedProtocol' do
+      mprot = Thrift::MultiplexedProtocol.new(binary_protocol, 'svc')
+      struct_chain(3).write(mprot)
+      result = SpecNamespace::RecTree.new
+      result.read(mprot)
+      expect(tree_depth(result)).to eq(3)
+    end
+  end
+
+  # Only present when the native (thrift_native) extension is loaded, which
+  # also makes Thrift::Struct#read/#write the native implementations -- the path
+  # that must enforce the limit in C, not just in pure Ruby.
+  if defined? Thrift::BinaryProtocolAccelerated
+    describe 'accelerated binary protocol' do
+      it 'rejects writing a chain past the limit' do
+        pending PENDING_REASON
+        prot = Thrift::BinaryProtocolAccelerated.new(Thrift::MemoryBufferTransport.new)
+        expect_depth_limit { struct_chain(RECURSION_LIMIT + 1).write(prot) }
+      end
+
+      it 'rejects reading a payload past the limit' do
+        pending PENDING_REASON
+        prot = Thrift::BinaryProtocolAccelerated.new(Thrift::MemoryBufferTransport.new)
+        write_raw_tree(prot, RECURSION_LIMIT + 1)
+        expect_depth_limit { SpecNamespace::RecTree.new.read(prot) }
+      end
+    end
+  end
+end

data/spec/serializer_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -20,7 +21,6 @@
 require 'spec_helper'
 
 describe 'Serializer' do
-
   describe Thrift::Serializer do
     it "should serialize structs to binary by default" do
       serializer = Thrift::Serializer.new(Thrift::BinaryProtocolAcceleratedFactory.new)

data/spec/server_socket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -21,7 +22,6 @@ require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
 describe 'Thrift::ServerSocket' do
-
   describe Thrift::ServerSocket do
     before(:each) do
       @socket = Thrift::ServerSocket.new(1234)
@@ -44,13 +44,50 @@ describe 'Thrift::ServerSocket' do
       expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
       @socket.listen
       sock = double("sock")
+      expect(sock).to receive(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
       expect(handle).to receive(:accept).and_return(sock)
       trans = double("Socket")
       expect(Thrift::Socket).to receive(:new).and_return(trans)
+      expect(trans).to receive(:timeout=).with(Thrift::BaseServerTransport::DEFAULT_CLIENT_TIMEOUT)
       expect(trans).to receive(:handle=).with(sock)
       expect(@socket.accept).to eq(trans)
     end
 
+    it "should default accepted sockets to a finite client timeout" do
+      expect(@socket.client_timeout).to eq(5)
+    end
+
+    it "should accept a custom client timeout" do
+      @socket = Thrift::ServerSocket.new(1234, client_timeout: 2.5)
+      expect(@socket.client_timeout).to eq(2.5)
+    end
+
+    it "should allow blocking accepted sockets with nil or zero client timeout" do
+      expect(Thrift::ServerSocket.new(1234, client_timeout: nil).client_timeout).to be_nil
+      expect(Thrift::ServerSocket.new(1234, client_timeout: 0).client_timeout).to eq(0)
+    end
+
+    it "should use the accepted socket timeout for writes" do
+      handle = double("TCPServer")
+      allow(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
+      @socket.listen
+
+      sock = double("sock", :closed? => false)
+      allow(sock).to receive(:setsockopt)
+      allow(handle).to receive(:accept).and_return(sock)
+
+      transport = @socket.accept
+      expect(transport.timeout).to eq(Thrift::BaseServerTransport::DEFAULT_CLIENT_TIMEOUT)
+
+      expect(sock).to receive(:write_nonblock).with("test data").and_raise(IO::EAGAINWaitWritable)
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 100.0, 105.1)
+      expect(IO).to receive(:select).with(nil, [sock], nil, 5.0).and_return(nil)
+
+      expect { transport.write("test data") }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+      end
+    end
+
     it "should close the handle when closed" do
       handle = double("TCPServer", :closed? => false)
       expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)

data/spec/server_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -17,9 +18,9 @@
 # under the License.
 #
 require 'spec_helper'
+require 'openssl'
 
 describe 'Server' do
-
   describe Thrift::BaseServer do
     before(:each) do
       @processor = double("Processor")
@@ -36,9 +37,9 @@ describe 'Server' do
     end
 
     it "should not serve" do
-      expect { @server.serve()}.to raise_error(NotImplementedError)
+      expect { @server.serve() }.to raise_error(NotImplementedError)
     end
-    
+
     it "should provide a reasonable to_s" do
       expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
       expect(@trans).to receive(:to_s).once.and_return("trans")
@@ -56,14 +57,14 @@ describe 'Server' do
       @client = double("Client")
       @server = described_class.new(@processor, @serverTrans, @trans, @prot)
     end
-    
+
     it "should provide a reasonable to_s" do
       expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
       expect(@trans).to receive(:to_s).once.and_return("trans")
       expect(@prot).to receive(:to_s).once.and_return("prot")
       expect(@server.to_s).to eq("simple(server(prot(trans(serverTrans))))")
     end
-    
+
     it "should serve in the main thread" do
       expect(@serverTrans).to receive(:listen).ordered
       expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
@@ -81,6 +82,30 @@ describe 'Server' do
       expect(@serverTrans).to receive(:close).ordered
       expect { @server.serve }.to throw_symbol(:stop)
     end
+
+    it "should continue serving after accept raises Errno::ECONNRESET" do
+      expect(@serverTrans).to receive(:listen).ordered
+      expect(@serverTrans).to receive(:accept).ordered.and_raise(Errno::ECONNRESET)
+      expect(@serverTrans).to receive(:accept).ordered.and_return(@client)
+      expect(@trans).to receive(:get_transport).once.with(@client).and_return(@trans)
+      expect(@prot).to receive(:get_protocol).once.with(@trans).and_return(@prot)
+      expect(@processor).to receive(:process).once.with(@prot, @prot) { throw :stop }
+      expect(@trans).to receive(:close).once
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
+    end
+
+    it "should continue serving after accept raises OpenSSL::SSL::SSLError" do
+      expect(@serverTrans).to receive(:listen).ordered
+      expect(@serverTrans).to receive(:accept).ordered.and_raise(OpenSSL::SSL::SSLError)
+      expect(@serverTrans).to receive(:accept).ordered.and_return(@client)
+      expect(@trans).to receive(:get_transport).once.with(@client).and_return(@trans)
+      expect(@prot).to receive(:get_protocol).once.with(@trans).and_return(@prot)
+      expect(@processor).to receive(:process).once.with(@prot, @prot) { throw :stop }
+      expect(@trans).to receive(:close).once
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
+    end
   end
 
   describe Thrift::ThreadedServer do
@@ -99,7 +124,7 @@ describe 'Server' do
       expect(@prot).to receive(:to_s).once.and_return("prot")
       expect(@server.to_s).to eq("threaded(server(prot(trans(serverTrans))))")
     end
-    
+
     it "should serve using threads" do
       expect(@serverTrans).to receive(:listen).ordered
       expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
@@ -118,6 +143,32 @@ describe 'Server' do
       expect(@serverTrans).to receive(:close).ordered
       expect { @server.serve }.to throw_symbol(:stop)
     end
+
+    it "should continue serving after accept raises Errno::ECONNRESET" do
+      expect(@serverTrans).to receive(:listen).ordered
+      expect(@serverTrans).to receive(:accept).ordered.and_raise(Errno::ECONNRESET)
+      expect(@serverTrans).to receive(:accept).ordered.and_return(@client)
+      expect(@trans).to receive(:get_transport).once.with(@client).and_return(@trans)
+      expect(@prot).to receive(:get_protocol).once.with(@trans).and_return(@prot)
+      expect(Thread).to receive(:new).with(@prot, @trans).once.and_yield(@prot, @trans)
+      expect(@processor).to receive(:process).once.with(@prot, @prot) { throw :stop }
+      expect(@trans).to receive(:close).once
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
+    end
+
+    it "should continue serving after accept raises OpenSSL::SSL::SSLError" do
+      expect(@serverTrans).to receive(:listen).ordered
+      expect(@serverTrans).to receive(:accept).ordered.and_raise(OpenSSL::SSL::SSLError)
+      expect(@serverTrans).to receive(:accept).ordered.and_return(@client)
+      expect(@trans).to receive(:get_transport).once.with(@client).and_return(@trans)
+      expect(@prot).to receive(:get_protocol).once.with(@trans).and_return(@prot)
+      expect(Thread).to receive(:new).with(@prot, @trans).once.and_yield(@prot, @trans)
+      expect(@processor).to receive(:process).once.with(@prot, @prot) { throw :stop }
+      expect(@trans).to receive(:close).once
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
+    end
   end
 
   describe Thrift::ThreadPoolServer do
@@ -137,10 +188,10 @@ describe 'Server' do
       expect(@prot).to receive(:to_s).once.and_return("prot")
       expect(@server.to_s).to eq("threadpool(server(prot(trans(server_trans))))")
     end
-    
+
     it "should serve inside a thread" do
       exception_q = @server.instance_variable_get(:@exception_q)
-      expect_any_instance_of(described_class).to receive(:serve) do 
+      expect_any_instance_of(described_class).to receive(:serve) do
         exception_q.push(StandardError.new('ERROR'))
       end
       expect { @server.rescuable_serve }.to(raise_error('ERROR'))
@@ -149,7 +200,7 @@ describe 'Server' do
 
     it "should avoid running the server twice when retrying rescuable_serve" do
       exception_q = @server.instance_variable_get(:@exception_q)
-      expect_any_instance_of(described_class).to receive(:serve) do 
+      expect_any_instance_of(described_class).to receive(:serve) do
         exception_q.push(StandardError.new('ERROR1'))
         exception_q.push(StandardError.new('ERROR2'))
       end

data/spec/socket_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -21,48 +22,153 @@ require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
 describe 'Socket' do
-
   describe Thrift::Socket do
     before(:each) do
       @socket = Thrift::Socket.new
+      @addrinfo = double("Addrinfo")
       @handle = double("Handle", :closed? => false)
       allow(@handle).to receive(:close)
-      allow(@handle).to receive(:connect_nonblock)
       allow(@handle).to receive(:setsockopt)
-      allow(::Socket).to receive(:new).and_return(@handle)
+      allow(@addrinfo).to receive(:connect).and_return(@handle)
+      allow(Addrinfo).to receive(:foreach).and_yield(@addrinfo)
     end
 
     it_should_behave_like "a socket"
 
     it "should raise a TransportException when it cannot open a socket" do
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
+      allow(Addrinfo).to receive(:foreach).and_raise(SocketError.new("lookup failed"))
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause).to be_a(SocketError)
+      end
     end
 
     it "should open a ::Socket with default args" do
-      expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
-      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo)
+      expect(@addrinfo).to receive(:connect).with(no_args).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
       @socket.to_s == "socket(localhost:9090)"
       @socket.open
     end
 
     it "should accept host/port options" do
-      expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
-      expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      expect(::Socket).to receive(:sockaddr_in)
+      handle = double("Handle", :closed? => false)
+      allow(handle).to receive(:close)
+      expect(handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+      expect(Addrinfo).to receive(:foreach).with("my.domain", 1234, nil, :STREAM).and_yield(@addrinfo)
+      expect(@addrinfo).to receive(:connect).with(no_args).and_return(handle)
       @socket = Thrift::Socket.new('my.domain', 1234).open
       @socket.to_s == "socket(my.domain:1234)"
     end
 
     it "should accept an optional timeout" do
-      allow(::Socket).to receive(:new)
       expect(Thrift::Socket.new('localhost', 8080, 5).timeout).to eq(5)
     end
 
     it "should provide a reasonable to_s" do
-      allow(::Socket).to receive(:new)
       expect(Thrift::Socket.new('myhost', 8090).to_s).to eq("socket(myhost:8090)")
     end
+
+    it "should pass the remaining timeout to each address attempt" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 103.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ECONNREFUSED)
+      expect(second_addrinfo).to receive(:connect).with(timeout: 2.0).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should continue to the next address after a connect timeout while time remains" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 103.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ETIMEDOUT)
+      expect(second_addrinfo).to receive(:connect).with(timeout: 2.0).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should raise TIMED_OUT when an address attempt times out" do
+      @socket.timeout = 5
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ETIMEDOUT)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+        expect(e.message).to eq("Socket: Timed out opening connection to localhost:9090")
+      end
+    end
+
+    it "should raise TIMED_OUT when the deadline expires before the next address attempt" do
+      @socket.timeout = 5
+      second_addrinfo = double("Addrinfo")
+
+      expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0, 101.0, 105.0)
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).with(timeout: 4.0).and_raise(Errno::ECONNREFUSED)
+      expect(second_addrinfo).not_to receive(:connect)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::TIMED_OUT)
+        expect(e.message).to eq("Socket: Timed out opening connection to localhost:9090")
+      end
+    end
+
+    it "should treat zero timeout as blocking for open" do
+      @socket.timeout = 0
+
+      expect(@addrinfo).to receive(:connect).with(no_args).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should report the last connection error when all addresses fail" do
+      second_addrinfo = double("Addrinfo")
+
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(@addrinfo).and_yield(second_addrinfo)
+      expect(@addrinfo).to receive(:connect).and_raise(Errno::ECONNREFUSED)
+      expect(second_addrinfo).to receive(:connect).and_raise(Errno::EHOSTUNREACH)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+        expect(e.cause).to be_a(Errno::EHOSTUNREACH)
+      end
+    end
+
+    it "should close a connected candidate before falling back when socket setup fails" do
+      first_addrinfo = @addrinfo
+      second_addrinfo = double("Addrinfo")
+      first_handle = double("Handle", :closed? => false)
+      allow(first_handle).to receive(:close)
+
+      expect(Addrinfo).to receive(:foreach).with("localhost", 9090, nil, :STREAM).and_yield(first_addrinfo).and_yield(second_addrinfo)
+      expect(first_addrinfo).to receive(:connect).with(no_args).and_return(first_handle)
+      expect(first_handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1).and_raise(StandardError.new("setsockopt failed"))
+      expect(first_handle).to receive(:close)
+      expect(second_addrinfo).to receive(:connect).with(no_args).and_return(@handle)
+      expect(@handle).to receive(:setsockopt).with(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      expect(@socket.open).to eq(@handle)
+    end
+
+    it "should avoid a blank error when no addresses are returned" do
+      allow(Addrinfo).to receive(:foreach)
+
+      expect { @socket.open }.to raise_error(Thrift::TransportException) do |e|
+        expect(e.type).to eq(Thrift::TransportException::NOT_OPEN)
+        expect(e.message).to eq("Could not connect to localhost:9090")
+      end
+    end
   end
 end