thrift 0.24.0 → 0.25.0

data/spec/recursion_depth_spec.rb

@@ -1,223 +0,0 @@
-# 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,67 +0,0 @@
-# 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'
-
-describe 'Serializer' do
-  describe Thrift::Serializer do
-    it "should serialize structs to binary by default" do
-      serializer = Thrift::Serializer.new(Thrift::BinaryProtocolAcceleratedFactory.new)
-      data = serializer.serialize(SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!"))
-      expect(data).to eq("\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00")
-    end
-
-    it "should serialize structs to the given protocol" do
-      protocol = Thrift::BaseProtocol.new(double("transport"))
-      expect(protocol).to receive(:write_struct_begin).with("SpecNamespace::Hello")
-      expect(protocol).to receive(:write_field_begin).with("greeting", Thrift::Types::STRING, 1)
-      expect(protocol).to receive(:write_string).with("Good day")
-      expect(protocol).to receive(:write_field_end)
-      expect(protocol).to receive(:write_field_stop)
-      expect(protocol).to receive(:write_struct_end)
-      protocol_factory = double("ProtocolFactory")
-      allow(protocol_factory).to receive(:get_protocol).and_return(protocol)
-      serializer = Thrift::Serializer.new(protocol_factory)
-      serializer.serialize(SpecNamespace::Hello.new(:greeting => "Good day"))
-    end
-  end
-
-  describe Thrift::Deserializer do
-    it "should deserialize structs from binary by default" do
-      deserializer = Thrift::Deserializer.new
-      data = "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
-      expect(deserializer.deserialize(SpecNamespace::Hello.new, data)).to eq(SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!"))
-    end
-
-    it "should deserialize structs from the given protocol" do
-      protocol = Thrift::BaseProtocol.new(double("transport"))
-      expect(protocol).to receive(:read_struct_begin).and_return("SpecNamespace::Hello")
-      expect(protocol).to receive(:read_field_begin).and_return(["greeting", Thrift::Types::STRING, 1],
-                                                            [nil, Thrift::Types::STOP, 0])
-      expect(protocol).to receive(:read_string).and_return("Good day")
-      expect(protocol).to receive(:read_field_end)
-      expect(protocol).to receive(:read_struct_end)
-      protocol_factory = double("ProtocolFactory")
-      allow(protocol_factory).to receive(:get_protocol).and_return(protocol)
-      deserializer = Thrift::Deserializer.new(protocol_factory)
-      expect(deserializer.deserialize(SpecNamespace::Hello.new, "")).to eq(SpecNamespace::Hello.new(:greeting => "Good day"))
-    end
-  end
-end

data/spec/server_socket_spec.rb

@@ -1,121 +0,0 @@
-# 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'
-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)
-    end
-
-    it "should create a handle when calling listen" do
-      expect(TCPServer).to receive(:new).with(nil, 1234)
-      @socket.listen
-    end
-
-    it "should accept an optional host argument" do
-      @socket = Thrift::ServerSocket.new('localhost', 1234)
-      expect(TCPServer).to receive(:new).with('localhost', 1234)
-      @socket.to_s == "server(localhost:1234)"
-      @socket.listen
-    end
-
-    it "should create a Thrift::Socket to wrap accepted sockets" do
-      handle = double("TCPServer")
-      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)
-      @socket.listen
-      expect(handle).to receive(:close)
-      @socket.close
-    end
-
-    it "should return nil when accepting if there is no handle" do
-      expect(@socket.accept).to be_nil
-    end
-
-    it "should return true for closed? when appropriate" do
-      handle = double("TCPServer", :closed? => false)
-      allow(TCPServer).to receive(:new).and_return(handle)
-      @socket.listen
-      expect(@socket).not_to be_closed
-      allow(handle).to receive(:close)
-      @socket.close
-      expect(@socket).to be_closed
-      @socket.listen
-      expect(@socket).not_to be_closed
-      allow(handle).to receive(:closed?).and_return(true)
-      expect(@socket).to be_closed
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@socket.to_s).to eq("socket(:1234)")
-    end
-  end
-end

data/spec/server_spec.rb

@@ -1,238 +0,0 @@
-# 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'
-require 'openssl'
-
-describe 'Server' do
-  describe Thrift::BaseServer do
-    before(:each) do
-      @processor = double("Processor")
-      @serverTrans = double("ServerTransport")
-      @trans = double("BaseTransport")
-      @prot = double("BaseProtocol")
-      @server = described_class.new(@processor, @serverTrans, @trans, @prot)
-    end
-
-    it "should default to BaseTransportFactory and BinaryProtocolFactory when not specified" do
-      @server = Thrift::BaseServer.new(double("Processor"), double("BaseServerTransport"))
-      expect(@server.instance_variable_get(:'@transport_factory')).to be_an_instance_of(Thrift::BaseTransportFactory)
-      expect(@server.instance_variable_get(:'@protocol_factory')).to be_an_instance_of(Thrift::BinaryProtocolFactory)
-    end
-
-    it "should not serve" do
-      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")
-      expect(@prot).to receive(:to_s).once.and_return("prot")
-      expect(@server.to_s).to eq("server(prot(trans(serverTrans)))")
-    end
-  end
-
-  describe Thrift::SimpleServer do
-    before(:each) do
-      @processor = double("Processor")
-      @serverTrans = double("ServerTransport")
-      @trans = double("BaseTransport")
-      @prot = double("BaseProtocol")
-      @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)
-      expect(@trans).to receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
-      expect(@prot).to receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
-      x = 0
-      expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then throw :stop
-        end
-      end
-      expect(@trans).to receive(:close).exactly(3).times
-      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
-    before(:each) do
-      @processor = double("Processor")
-      @serverTrans = double("ServerTransport")
-      @trans = double("BaseTransport")
-      @prot = double("BaseProtocol")
-      @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("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)
-      expect(@trans).to receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
-      expect(@prot).to receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
-      expect(Thread).to receive(:new).with(@prot, @trans).exactly(3).times.and_yield(@prot, @trans)
-      x = 0
-      expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then throw :stop
-        end
-      end
-      expect(@trans).to receive(:close).exactly(3).times
-      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
-    before(:each) do
-      @processor = double("Processor")
-      @server_trans = double("ServerTransport")
-      @trans = double("BaseTransport")
-      @prot = double("BaseProtocol")
-      @client = double("Client")
-      @server = described_class.new(@processor, @server_trans, @trans, @prot)
-      sleep(0.15)
-    end
-
-    it "should provide a reasonable to_s" do
-      expect(@server_trans).to receive(:to_s).once.and_return("server_trans")
-      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("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
-        exception_q.push(StandardError.new('ERROR'))
-      end
-      expect { @server.rescuable_serve }.to(raise_error('ERROR'))
-      sleep(0.15)
-    end
-
-    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
-        exception_q.push(StandardError.new('ERROR1'))
-        exception_q.push(StandardError.new('ERROR2'))
-      end
-      expect { @server.rescuable_serve }.to(raise_error('ERROR1'))
-      expect { @server.rescuable_serve }.to(raise_error('ERROR2'))
-    end
-
-    it "should serve using a thread pool" do
-      thread_q = double("SizedQueue")
-      exception_q = double("Queue")
-      @server.instance_variable_set(:@thread_q, thread_q)
-      @server.instance_variable_set(:@exception_q, exception_q)
-      expect(@server_trans).to receive(:listen).ordered
-      expect(thread_q).to receive(:push).with(:token)
-      expect(thread_q).to receive(:pop)
-      expect(Thread).to receive(:new).and_yield
-      expect(@server_trans).to receive(:accept).exactly(3).times.and_return(@client)
-      expect(@trans).to receive(:get_transport).exactly(3).times.and_return(@trans)
-      expect(@prot).to receive(:get_protocol).exactly(3).times.and_return(@prot)
-      x = 0
-      error = RuntimeError.new("Stopped")
-      expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
-        case (x += 1)
-        when 1 then raise Thrift::TransportException
-        when 2 then raise Thrift::ProtocolException
-        when 3 then raise error
-        end
-      end
-      expect(@trans).to receive(:close).exactly(3).times
-      expect(exception_q).to receive(:push).with(error).and_throw(:stop)
-      expect(@server_trans).to receive(:close)
-      expect { @server.serve }.to(throw_symbol(:stop))
-    end
-  end
-end