thrift 0.9.3.0 → 0.14.0

data/lib/thrift/transport/server_socket.rb

@@ -59,5 +59,10 @@ module Thrift
     end
 
     alias to_io handle
+
+    def to_s
+      "socket(#{@host}:#{@port})"
+    end
+
   end
-end
+end

data/lib/thrift/transport/socket.rb

@@ -33,26 +33,28 @@ module Thrift
     attr_accessor :handle, :timeout
 
     def open
-      begin
-        addrinfo = ::Socket::getaddrinfo(@host, @port, nil, ::Socket::SOCK_STREAM).first
-        @handle = ::Socket.new(addrinfo[4], ::Socket::SOCK_STREAM, 0)
-        @handle.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
-        sockaddr = ::Socket.sockaddr_in(addrinfo[1], addrinfo[3])
+      for addrinfo in ::Socket::getaddrinfo(@host, @port, nil, ::Socket::SOCK_STREAM) do
         begin
-          @handle.connect_nonblock(sockaddr)
-        rescue Errno::EINPROGRESS
-          unless IO.select(nil, [ @handle ], nil, @timeout)
-            raise TransportException.new(TransportException::NOT_OPEN, "Connection timeout to #{@desc}")
-          end
+          socket = ::Socket.new(addrinfo[4], ::Socket::SOCK_STREAM, 0)
+          socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+          sockaddr = ::Socket.sockaddr_in(addrinfo[1], addrinfo[3])
           begin
-            @handle.connect_nonblock(sockaddr)
-          rescue Errno::EISCONN
+            socket.connect_nonblock(sockaddr)
+          rescue Errno::EINPROGRESS
+            unless IO.select(nil, [ socket ], nil, @timeout)
+              next
+            end
+            begin
+              socket.connect_nonblock(sockaddr)
+            rescue Errno::EISCONN
+            end
           end
+          return @handle = socket
+        rescue StandardError => e
+          next
         end
-        @handle
-      rescue StandardError => e
-        raise TransportException.new(TransportException::NOT_OPEN, "Could not connect to #{@desc}: #{e}")
       end
+      raise TransportException.new(TransportException::NOT_OPEN, "Could not connect to #{@desc}: #{e}")
     end
 
     def open?
@@ -132,8 +134,10 @@ module Thrift
       @handle = nil
     end
 
-    def to_io
-      @handle
+    alias to_io handle
+
+    def to_s
+      "socket(#{@host}:#{@port})"
     end
   end
 end

data/lib/thrift/transport/ssl_server_socket.rb

@@ -0,0 +1,41 @@
+# encoding: ascii-8bit
+#
+# 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 'socket'
+
+module Thrift
+  class SSLServerSocket < ServerSocket
+    def initialize(host_or_port, port = nil, ssl_context = nil)
+      super(host_or_port, port)
+      @ssl_context = ssl_context
+    end
+
+    attr_accessor :ssl_context
+
+    def listen
+      socket = TCPServer.new(@host, @port)
+      @handle = OpenSSL::SSL::SSLServer.new(socket, @ssl_context)
+    end
+    
+    def to_s
+      "ssl(#{super.to_s})"
+    end
+  end
+end

data/lib/thrift/transport/ssl_socket.rb

@@ -0,0 +1,51 @@
+# encoding: ascii-8bit
+#
+# 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.
+
+module Thrift
+  class SSLSocket < Socket
+    def initialize(host='localhost', port=9090, timeout=nil, ssl_context=nil)
+      super(host, port, timeout)
+      @ssl_context = ssl_context
+    end
+
+    attr_accessor :ssl_context
+
+    def open
+      socket = super
+      @handle = OpenSSL::SSL::SSLSocket.new(socket, @ssl_context)
+      begin
+        @handle.connect_nonblock
+        @handle.post_connection_check(@host)
+        @handle
+      rescue IO::WaitReadable
+        IO.select([ @handle ], nil, nil, @timeout)
+        retry
+      rescue IO::WaitWritable
+        IO.select(nil, [ @handle ], nil, @timeout)
+        retry
+      rescue StandardError => e
+        raise TransportException.new(TransportException::NOT_OPEN, "Could not connect to #{@desc}: #{e}")
+      end
+    end
+    
+    def to_s
+      "ssl(#{super.to_s})"
+    end
+  end
+end

data/lib/thrift/transport/unix_server_socket.rb

@@ -56,5 +56,9 @@ module Thrift
     end
 
     alias to_io handle
+
+    def to_s
+      "domain(#{@path})"
+    end
   end
-end
+end

data/lib/thrift/transport/unix_socket.rb

@@ -36,5 +36,9 @@ module Thrift
         raise TransportException.new(TransportException::NOT_OPEN, "Could not open UNIX socket at #{@path}")
       end
     end
+    
+    def to_s
+      "domain(#{@path})"
+    end
   end
-end
+end

data/spec/base_protocol_spec.rb

@@ -22,41 +22,46 @@ require 'spec_helper'
 describe 'BaseProtocol' do
 
   before(:each) do
-    @trans = mock("MockTransport")
+    @trans = double("MockTransport")
     @prot = Thrift::BaseProtocol.new(@trans)
   end
 
   describe Thrift::BaseProtocol do
     # most of the methods are stubs, so we can ignore them
 
+    it "should provide a reasonable to_s" do
+      expect(@trans).to receive(:to_s).once.and_return("trans")
+      expect(@prot.to_s).to eq("trans")
+    end
+
     it "should make trans accessible" do
-      @prot.trans.should eql(@trans)
+      expect(@prot.trans).to eql(@trans)
     end
 
     it 'should write out a field nicely (deprecated write_field signature)' do
-      @prot.should_receive(:write_field_begin).with('field', 'type', 'fid').ordered
-      @prot.should_receive(:write_type).with({:name => 'field', :type => 'type'}, 'value').ordered
-      @prot.should_receive(:write_field_end).ordered
+      expect(@prot).to receive(:write_field_begin).with('field', 'type', 'fid').ordered
+      expect(@prot).to receive(:write_type).with({:name => 'field', :type => 'type'}, 'value').ordered
+      expect(@prot).to receive(:write_field_end).ordered
       @prot.write_field('field', 'type', 'fid', 'value')
     end
 
     it 'should write out a field nicely' do
-      @prot.should_receive(:write_field_begin).with('field', 'type', 'fid').ordered
-      @prot.should_receive(:write_type).with({:name => 'field', :type => 'type', :binary => false}, 'value').ordered
-      @prot.should_receive(:write_field_end).ordered
+      expect(@prot).to receive(:write_field_begin).with('field', 'type', 'fid').ordered
+      expect(@prot).to receive(:write_type).with({:name => 'field', :type => 'type', :binary => false}, 'value').ordered
+      expect(@prot).to receive(:write_field_end).ordered
       @prot.write_field({:name => 'field', :type => 'type', :binary => false}, 'fid', 'value')
     end
 
     it 'should write out the different types (deprecated write_type signature)' do
-      @prot.should_receive(:write_bool).with('bool').ordered
-      @prot.should_receive(:write_byte).with('byte').ordered
-      @prot.should_receive(:write_double).with('double').ordered
-      @prot.should_receive(:write_i16).with('i16').ordered
-      @prot.should_receive(:write_i32).with('i32').ordered
-      @prot.should_receive(:write_i64).with('i64').ordered
-      @prot.should_receive(:write_string).with('string').ordered
-      struct = mock('Struct')
-      struct.should_receive(:write).with(@prot).ordered
+      expect(@prot).to receive(:write_bool).with('bool').ordered
+      expect(@prot).to receive(:write_byte).with('byte').ordered
+      expect(@prot).to receive(:write_double).with('double').ordered
+      expect(@prot).to receive(:write_i16).with('i16').ordered
+      expect(@prot).to receive(:write_i32).with('i32').ordered
+      expect(@prot).to receive(:write_i64).with('i64').ordered
+      expect(@prot).to receive(:write_string).with('string').ordered
+      struct = double('Struct')
+      expect(struct).to receive(:write).with(@prot).ordered
       @prot.write_type(Thrift::Types::BOOL, 'bool')
       @prot.write_type(Thrift::Types::BYTE, 'byte')
       @prot.write_type(Thrift::Types::DOUBLE, 'double')
@@ -72,16 +77,16 @@ describe 'BaseProtocol' do
     end
 
     it 'should write out the different types' do
-      @prot.should_receive(:write_bool).with('bool').ordered
-      @prot.should_receive(:write_byte).with('byte').ordered
-      @prot.should_receive(:write_double).with('double').ordered
-      @prot.should_receive(:write_i16).with('i16').ordered
-      @prot.should_receive(:write_i32).with('i32').ordered
-      @prot.should_receive(:write_i64).with('i64').ordered
-      @prot.should_receive(:write_string).with('string').ordered
-      @prot.should_receive(:write_binary).with('binary').ordered
-      struct = mock('Struct')
-      struct.should_receive(:write).with(@prot).ordered
+      expect(@prot).to receive(:write_bool).with('bool').ordered
+      expect(@prot).to receive(:write_byte).with('byte').ordered
+      expect(@prot).to receive(:write_double).with('double').ordered
+      expect(@prot).to receive(:write_i16).with('i16').ordered
+      expect(@prot).to receive(:write_i32).with('i32').ordered
+      expect(@prot).to receive(:write_i64).with('i64').ordered
+      expect(@prot).to receive(:write_string).with('string').ordered
+      expect(@prot).to receive(:write_binary).with('binary').ordered
+      struct = double('Struct')
+      expect(struct).to receive(:write).with(@prot).ordered
       @prot.write_type({:type => Thrift::Types::BOOL}, 'bool')
       @prot.write_type({:type => Thrift::Types::BYTE}, 'byte')
       @prot.write_type({:type => Thrift::Types::DOUBLE}, 'double')
@@ -98,13 +103,13 @@ describe 'BaseProtocol' do
     end
 
     it 'should read the different types (deprecated read_type signature)' do
-      @prot.should_receive(:read_bool).ordered
-      @prot.should_receive(:read_byte).ordered
-      @prot.should_receive(:read_i16).ordered
-      @prot.should_receive(:read_i32).ordered
-      @prot.should_receive(:read_i64).ordered
-      @prot.should_receive(:read_double).ordered
-      @prot.should_receive(:read_string).ordered
+      expect(@prot).to receive(:read_bool).ordered
+      expect(@prot).to receive(:read_byte).ordered
+      expect(@prot).to receive(:read_i16).ordered
+      expect(@prot).to receive(:read_i32).ordered
+      expect(@prot).to receive(:read_i64).ordered
+      expect(@prot).to receive(:read_double).ordered
+      expect(@prot).to receive(:read_string).ordered
       @prot.read_type(Thrift::Types::BOOL)
       @prot.read_type(Thrift::Types::BYTE)
       @prot.read_type(Thrift::Types::I16)
@@ -120,14 +125,14 @@ describe 'BaseProtocol' do
     end
 
     it 'should read the different types' do
-      @prot.should_receive(:read_bool).ordered
-      @prot.should_receive(:read_byte).ordered
-      @prot.should_receive(:read_i16).ordered
-      @prot.should_receive(:read_i32).ordered
-      @prot.should_receive(:read_i64).ordered
-      @prot.should_receive(:read_double).ordered
-      @prot.should_receive(:read_string).ordered
-      @prot.should_receive(:read_binary).ordered
+      expect(@prot).to receive(:read_bool).ordered
+      expect(@prot).to receive(:read_byte).ordered
+      expect(@prot).to receive(:read_i16).ordered
+      expect(@prot).to receive(:read_i32).ordered
+      expect(@prot).to receive(:read_i64).ordered
+      expect(@prot).to receive(:read_double).ordered
+      expect(@prot).to receive(:read_string).ordered
+      expect(@prot).to receive(:read_binary).ordered
       @prot.read_type({:type => Thrift::Types::BOOL})
       @prot.read_type({:type => Thrift::Types::BYTE})
       @prot.read_type({:type => Thrift::Types::I16})
@@ -144,13 +149,13 @@ describe 'BaseProtocol' do
     end
 
     it "should skip the basic types" do
-      @prot.should_receive(:read_bool).ordered
-      @prot.should_receive(:read_byte).ordered
-      @prot.should_receive(:read_i16).ordered
-      @prot.should_receive(:read_i32).ordered
-      @prot.should_receive(:read_i64).ordered
-      @prot.should_receive(:read_double).ordered
-      @prot.should_receive(:read_string).ordered
+      expect(@prot).to receive(:read_bool).ordered
+      expect(@prot).to receive(:read_byte).ordered
+      expect(@prot).to receive(:read_i16).ordered
+      expect(@prot).to receive(:read_i32).ordered
+      expect(@prot).to receive(:read_i64).ordered
+      expect(@prot).to receive(:read_double).ordered
+      expect(@prot).to receive(:read_string).ordered
       @prot.skip(Thrift::Types::BOOL)
       @prot.skip(Thrift::Types::BYTE)
       @prot.skip(Thrift::Types::I16)
@@ -158,52 +163,51 @@ describe 'BaseProtocol' do
       @prot.skip(Thrift::Types::I64)
       @prot.skip(Thrift::Types::DOUBLE)
       @prot.skip(Thrift::Types::STRING)
-      @prot.skip(Thrift::Types::STOP) # should do absolutely nothing
     end
 
     it "should skip structs" do
       real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_struct_begin).ordered
-      @prot.should_receive(:read_field_begin).exactly(4).times.and_return(
+      expect(@prot).to receive(:read_struct_begin).ordered
+      expect(@prot).to receive(:read_field_begin).exactly(4).times.and_return(
         ['field 1', Thrift::Types::STRING, 1],
         ['field 2', Thrift::Types::I32, 2],
         ['field 3', Thrift::Types::MAP, 3],
         [nil, Thrift::Types::STOP, 0]
       )
-      @prot.should_receive(:read_field_end).exactly(3).times
-      @prot.should_receive(:read_string).exactly(3).times
-      @prot.should_receive(:read_i32).ordered
-      @prot.should_receive(:read_map_begin).ordered.and_return([Thrift::Types::STRING, Thrift::Types::STRING, 1])
+      expect(@prot).to receive(:read_field_end).exactly(3).times
+      expect(@prot).to receive(:read_string).exactly(3).times
+      expect(@prot).to receive(:read_i32).ordered
+      expect(@prot).to receive(:read_map_begin).ordered.and_return([Thrift::Types::STRING, Thrift::Types::STRING, 1])
       # @prot.should_receive(:read_string).exactly(2).times
-      @prot.should_receive(:read_map_end).ordered
-      @prot.should_receive(:read_struct_end).ordered
+      expect(@prot).to receive(:read_map_end).ordered
+      expect(@prot).to receive(:read_struct_end).ordered
       real_skip.call(Thrift::Types::STRUCT)
     end
 
     it "should skip maps" do
       real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_map_begin).ordered.and_return([Thrift::Types::STRING, Thrift::Types::STRUCT, 1])
-      @prot.should_receive(:read_string).ordered
-      @prot.should_receive(:read_struct_begin).ordered.and_return(["some_struct"])
-      @prot.should_receive(:read_field_begin).ordered.and_return([nil, Thrift::Types::STOP, nil]);
-      @prot.should_receive(:read_struct_end).ordered
-      @prot.should_receive(:read_map_end).ordered
+      expect(@prot).to receive(:read_map_begin).ordered.and_return([Thrift::Types::STRING, Thrift::Types::STRUCT, 1])
+      expect(@prot).to receive(:read_string).ordered
+      expect(@prot).to receive(:read_struct_begin).ordered.and_return(["some_struct"])
+      expect(@prot).to receive(:read_field_begin).ordered.and_return([nil, Thrift::Types::STOP, nil]);
+      expect(@prot).to receive(:read_struct_end).ordered
+      expect(@prot).to receive(:read_map_end).ordered
       real_skip.call(Thrift::Types::MAP)
     end
 
     it "should skip sets" do
       real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_set_begin).ordered.and_return([Thrift::Types::I64, 9])
-      @prot.should_receive(:read_i64).ordered.exactly(9).times
-      @prot.should_receive(:read_set_end)
+      expect(@prot).to receive(:read_set_begin).ordered.and_return([Thrift::Types::I64, 9])
+      expect(@prot).to receive(:read_i64).ordered.exactly(9).times
+      expect(@prot).to receive(:read_set_end)
       real_skip.call(Thrift::Types::SET)
     end
 
     it "should skip lists" do
       real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_list_begin).ordered.and_return([Thrift::Types::DOUBLE, 11])
-      @prot.should_receive(:read_double).ordered.exactly(11).times
-      @prot.should_receive(:read_list_end)
+      expect(@prot).to receive(:read_list_begin).ordered.and_return([Thrift::Types::DOUBLE, 11])
+      expect(@prot).to receive(:read_double).ordered.exactly(11).times
+      expect(@prot).to receive(:read_list_end)
       real_skip.call(Thrift::Types::LIST)
     end
   end
@@ -211,7 +215,11 @@ describe 'BaseProtocol' do
   describe Thrift::BaseProtocolFactory do
     it "should raise NotImplementedError" do
       # returning nil since Protocol is just an abstract class
-      lambda {Thrift::BaseProtocolFactory.new.get_protocol(mock("MockTransport"))}.should raise_error(NotImplementedError)
+      expect {Thrift::BaseProtocolFactory.new.get_protocol(double("MockTransport"))}.to raise_error(NotImplementedError)
+    end
+
+    it "should provide a reasonable to_s" do
+      expect(Thrift::BaseProtocolFactory.new.to_s).to eq("base")
     end
   end
 end

data/spec/base_transport_spec.rb

@@ -24,105 +24,119 @@ describe 'BaseTransport' do
   describe Thrift::TransportException do
     it "should make type accessible" do
       exc = Thrift::TransportException.new(Thrift::TransportException::ALREADY_OPEN, "msg")
-      exc.type.should == Thrift::TransportException::ALREADY_OPEN
-      exc.message.should == "msg"
+      expect(exc.type).to eq(Thrift::TransportException::ALREADY_OPEN)
+      expect(exc.message).to eq("msg")
     end
   end
 
   describe Thrift::BaseTransport do
     it "should read the specified size" do
       transport = Thrift::BaseTransport.new
-      transport.should_receive(:read).with(40).ordered.and_return("10 letters")
-      transport.should_receive(:read).with(30).ordered.and_return("fifteen letters")
-      transport.should_receive(:read).with(15).ordered.and_return("more characters")
-      transport.read_all(40).should == "10 lettersfifteen lettersmore characters"
+      expect(transport).to receive(:read).with(40).ordered.and_return("10 letters")
+      expect(transport).to receive(:read).with(30).ordered.and_return("fifteen letters")
+      expect(transport).to receive(:read).with(15).ordered.and_return("more characters")
+      expect(transport.read_all(40)).to eq("10 lettersfifteen lettersmore characters")
     end
 
     it "should stub out the rest of the methods" do
       # can't test for stubbiness, so just make sure they're defined
       [:open?, :open, :close, :read, :write, :flush].each do |sym|
-        Thrift::BaseTransport.method_defined?(sym).should be_true
+        expect(Thrift::BaseTransport.method_defined?(sym)).to be_truthy
       end
     end
 
     it "should alias << to write" do
-      Thrift::BaseTransport.instance_method(:<<).should == Thrift::BaseTransport.instance_method(:write)
+      expect(Thrift::BaseTransport.instance_method(:<<)).to eq(Thrift::BaseTransport.instance_method(:write))
+    end
+    
+    it "should provide a reasonable to_s" do
+      expect(Thrift::BaseTransport.new.to_s).to eq("base")
     end
   end
 
   describe Thrift::BaseServerTransport do
     it "should stub out its methods" do
       [:listen, :accept, :close].each do |sym|
-        Thrift::BaseServerTransport.method_defined?(sym).should be_true
+        expect(Thrift::BaseServerTransport.method_defined?(sym)).to be_truthy
       end
     end
   end
 
   describe Thrift::BaseTransportFactory do
     it "should return the transport it's given" do
-      transport = mock("Transport")
-      Thrift::BaseTransportFactory.new.get_transport(transport).should eql(transport)
+      transport = double("Transport")
+      expect(Thrift::BaseTransportFactory.new.get_transport(transport)).to eql(transport)
+    end
+    
+    it "should provide a reasonable to_s" do
+      expect(Thrift::BaseTransportFactory.new.to_s).to eq("base")
     end
   end
 
   describe Thrift::BufferedTransport do
+    it "should provide a to_s that describes the encapsulation" do
+      trans = double("Transport")
+      expect(trans).to receive(:to_s).and_return("mock")
+      expect(Thrift::BufferedTransport.new(trans).to_s).to eq("buffered(mock)")
+    end
+
     it "should pass through everything but write/flush/read" do
-      trans = mock("Transport")
-      trans.should_receive(:open?).ordered.and_return("+ open?")
-      trans.should_receive(:open).ordered.and_return("+ open")
-      trans.should_receive(:flush).ordered # from the close
-      trans.should_receive(:close).ordered.and_return("+ close")
+      trans = double("Transport")
+      expect(trans).to receive(:open?).ordered.and_return("+ open?")
+      expect(trans).to receive(:open).ordered.and_return("+ open")
+      expect(trans).to receive(:flush).ordered # from the close
+      expect(trans).to receive(:close).ordered.and_return("+ close")
       btrans = Thrift::BufferedTransport.new(trans)
-      btrans.open?.should == "+ open?"
-      btrans.open.should == "+ open"
-      btrans.close.should == "+ close"
+      expect(btrans.open?).to eq("+ open?")
+      expect(btrans.open).to eq("+ open")
+      expect(btrans.close).to eq("+ close")
     end
 
     it "should buffer reads in chunks of #{Thrift::BufferedTransport::DEFAULT_BUFFER}" do
-      trans = mock("Transport")
-      trans.should_receive(:read).with(Thrift::BufferedTransport::DEFAULT_BUFFER).and_return("lorum ipsum dolor emet")
+      trans = double("Transport")
+      expect(trans).to receive(:read).with(Thrift::BufferedTransport::DEFAULT_BUFFER).and_return("lorum ipsum dolor emet")
       btrans = Thrift::BufferedTransport.new(trans)
-      btrans.read(6).should == "lorum "
-      btrans.read(6).should == "ipsum "
-      btrans.read(6).should == "dolor "
-      btrans.read(6).should == "emet"
+      expect(btrans.read(6)).to eq("lorum ")
+      expect(btrans.read(6)).to eq("ipsum ")
+      expect(btrans.read(6)).to eq("dolor ")
+      expect(btrans.read(6)).to eq("emet")
     end
 
     it "should buffer writes and send them on flush" do
-      trans = mock("Transport")
+      trans = double("Transport")
       btrans = Thrift::BufferedTransport.new(trans)
       btrans.write("one/")
       btrans.write("two/")
       btrans.write("three/")
-      trans.should_receive(:write).with("one/two/three/").ordered
-      trans.should_receive(:flush).ordered
+      expect(trans).to receive(:write).with("one/two/three/").ordered
+      expect(trans).to receive(:flush).ordered
       btrans.flush
     end
 
     it "should only send buffered data once" do
-      trans = mock("Transport")
+      trans = double("Transport")
       btrans = Thrift::BufferedTransport.new(trans)
       btrans.write("one/")
       btrans.write("two/")
       btrans.write("three/")
-      trans.should_receive(:write).with("one/two/three/")
-      trans.stub!(:flush)
+      expect(trans).to receive(:write).with("one/two/three/")
+      allow(trans).to receive(:flush)
       btrans.flush
       # Nothing to flush with no data
       btrans.flush
     end
 
     it "should flush on close" do
-      trans = mock("Transport")
-      trans.should_receive(:close)
+      trans = double("Transport")
+      expect(trans).to receive(:close)
       btrans = Thrift::BufferedTransport.new(trans)
-      btrans.should_receive(:flush)
+      expect(btrans).to receive(:flush)
       btrans.close
     end
 
     it "should not write to socket if there's no data" do
-      trans = mock("Transport")
-      trans.should_receive(:flush)
+      trans = double("Transport")
+      expect(trans).to receive(:flush)
       btrans = Thrift::BufferedTransport.new(trans)
       btrans.flush
     end
@@ -130,80 +144,90 @@ describe 'BaseTransport' do
 
   describe Thrift::BufferedTransportFactory do
     it "should wrap the given transport in a BufferedTransport" do
-      trans = mock("Transport")
-      btrans = mock("BufferedTransport")
-      Thrift::BufferedTransport.should_receive(:new).with(trans).and_return(btrans)
-      Thrift::BufferedTransportFactory.new.get_transport(trans).should == btrans
+      trans = double("Transport")
+      btrans = double("BufferedTransport")
+      expect(Thrift::BufferedTransport).to receive(:new).with(trans).and_return(btrans)
+      expect(Thrift::BufferedTransportFactory.new.get_transport(trans)).to eq(btrans)
+    end
+    
+    it "should provide a reasonable to_s" do
+      expect(Thrift::BufferedTransportFactory.new.to_s).to eq("buffered")
     end
   end
 
   describe Thrift::FramedTransport do
     before(:each) do
-      @trans = mock("Transport")
+      @trans = double("Transport")
+    end
+
+    it "should provide a to_s that describes the encapsulation" do
+      trans = double("Transport")
+      expect(trans).to receive(:to_s).and_return("mock")
+      expect(Thrift::FramedTransport.new(trans).to_s).to eq("framed(mock)")
     end
 
     it "should pass through open?/open/close" do
       ftrans = Thrift::FramedTransport.new(@trans)
-      @trans.should_receive(:open?).ordered.and_return("+ open?")
-      @trans.should_receive(:open).ordered.and_return("+ open")
-      @trans.should_receive(:close).ordered.and_return("+ close")
-      ftrans.open?.should == "+ open?"
-      ftrans.open.should == "+ open"
-      ftrans.close.should == "+ close"
+      expect(@trans).to receive(:open?).ordered.and_return("+ open?")
+      expect(@trans).to receive(:open).ordered.and_return("+ open")
+      expect(@trans).to receive(:close).ordered.and_return("+ close")
+      expect(ftrans.open?).to eq("+ open?")
+      expect(ftrans.open).to eq("+ open")
+      expect(ftrans.close).to eq("+ close")
     end
 
     it "should pass through read when read is turned off" do
       ftrans = Thrift::FramedTransport.new(@trans, false, true)
-      @trans.should_receive(:read).with(17).ordered.and_return("+ read")
-      ftrans.read(17).should == "+ read"
+      expect(@trans).to receive(:read).with(17).ordered.and_return("+ read")
+      expect(ftrans.read(17)).to eq("+ read")
     end
 
     it "should pass through write/flush when write is turned off" do
       ftrans = Thrift::FramedTransport.new(@trans, true, false)
-      @trans.should_receive(:write).with("foo").ordered.and_return("+ write")
-      @trans.should_receive(:flush).ordered.and_return("+ flush")
-      ftrans.write("foo").should == "+ write"
-      ftrans.flush.should == "+ flush"
+      expect(@trans).to receive(:write).with("foo").ordered.and_return("+ write")
+      expect(@trans).to receive(:flush).ordered.and_return("+ flush")
+      expect(ftrans.write("foo")).to eq("+ write")
+      expect(ftrans.flush).to eq("+ flush")
     end
 
     it "should return a full frame if asked for >= the frame's length" do
       frame = "this is a frame"
-      @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017")
-      @trans.should_receive(:read_all).with(frame.length).and_return(frame)
-      Thrift::FramedTransport.new(@trans).read(frame.length + 10).should == frame
+      expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017")
+      expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
+      expect(Thrift::FramedTransport.new(@trans).read(frame.length + 10)).to eq(frame)
     end
 
     it "should return slices of the frame when asked for < the frame's length" do
       frame = "this is a frame"
-      @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017")
-      @trans.should_receive(:read_all).with(frame.length).and_return(frame)
+      expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017")
+      expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
       ftrans = Thrift::FramedTransport.new(@trans)
-      ftrans.read(4).should == "this"
-      ftrans.read(4).should == " is "
-      ftrans.read(16).should == "a frame"
+      expect(ftrans.read(4)).to eq("this")
+      expect(ftrans.read(4)).to eq(" is ")
+      expect(ftrans.read(16)).to eq("a frame")
     end
 
     it "should return nothing if asked for <= 0" do
-      Thrift::FramedTransport.new(@trans).read(-2).should == ""
+      expect(Thrift::FramedTransport.new(@trans).read(-2)).to eq("")
     end
 
     it "should pull a new frame when the first is exhausted" do
       frame = "this is a frame"
       frame2 = "yet another frame"
-      @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017", "\000\000\000\021")
-      @trans.should_receive(:read_all).with(frame.length).and_return(frame)
-      @trans.should_receive(:read_all).with(frame2.length).and_return(frame2)
+      expect(@trans).to receive(:read_all).with(4).and_return("\000\000\000\017", "\000\000\000\021")
+      expect(@trans).to receive(:read_all).with(frame.length).and_return(frame)
+      expect(@trans).to receive(:read_all).with(frame2.length).and_return(frame2)
       ftrans = Thrift::FramedTransport.new(@trans)
-      ftrans.read(4).should == "this"
-      ftrans.read(8).should == " is a fr"
-      ftrans.read(6).should == "ame"
-      ftrans.read(4).should == "yet "
-      ftrans.read(16).should == "another frame"
+      expect(ftrans.read(4)).to eq("this")
+      expect(ftrans.read(8)).to eq(" is a fr")
+      expect(ftrans.read(6)).to eq("ame")
+      expect(ftrans.read(4)).to eq("yet ")
+      expect(ftrans.read(16)).to eq("another frame")
     end
 
     it "should buffer writes" do
       ftrans = Thrift::FramedTransport.new(@trans)
-      @trans.should_not_receive(:write)
+      expect(@trans).not_to receive(:write)
       ftrans.write("foo")
       ftrans.write("bar")
       ftrans.write("this is a frame")
@@ -213,15 +237,15 @@ describe 'BaseTransport' do
       ftrans = Thrift::FramedTransport.new(@trans)
       ftrans.write("foobar", 3)
       ftrans.write("barfoo", 1)
-      @trans.stub!(:flush)
-      @trans.should_receive(:write).with("\000\000\000\004foob")
+      allow(@trans).to receive(:flush)
+      expect(@trans).to receive(:write).with("\000\000\000\004foob")
       ftrans.flush
     end
 
     it "should flush frames with a 4-byte header" do
       ftrans = Thrift::FramedTransport.new(@trans)
-      @trans.should_receive(:write).with("\000\000\000\035one/two/three/this is a frame").ordered
-      @trans.should_receive(:flush).ordered
+      expect(@trans).to receive(:write).with("\000\000\000\035one/two/three/this is a frame").ordered
+      expect(@trans).to receive(:flush).ordered
       ftrans.write("one/")
       ftrans.write("two/")
       ftrans.write("three/")
@@ -231,22 +255,26 @@ describe 'BaseTransport' do
 
     it "should not flush the same buffered data twice" do
       ftrans = Thrift::FramedTransport.new(@trans)
-      @trans.should_receive(:write).with("\000\000\000\007foo/bar")
-      @trans.stub!(:flush)
+      expect(@trans).to receive(:write).with("\000\000\000\007foo/bar")
+      allow(@trans).to receive(:flush)
       ftrans.write("foo")
       ftrans.write("/bar")
       ftrans.flush
-      @trans.should_receive(:write).with("\000\000\000\000")
+      expect(@trans).to receive(:write).with("\000\000\000\000")
       ftrans.flush
     end
   end
 
   describe Thrift::FramedTransportFactory do
     it "should wrap the given transport in a FramedTransport" do
-      trans = mock("Transport")
-      Thrift::FramedTransport.should_receive(:new).with(trans)
+      trans = double("Transport")
+      expect(Thrift::FramedTransport).to receive(:new).with(trans)
       Thrift::FramedTransportFactory.new.get_transport(trans)
     end
+    
+    it "should provide a reasonable to_s" do
+      expect(Thrift::FramedTransportFactory.new.to_s).to eq("framed")
+    end
   end
 
   describe Thrift::MemoryBufferTransport do
@@ -254,96 +282,106 @@ describe 'BaseTransport' do
       @buffer = Thrift::MemoryBufferTransport.new
     end
 
+    it "should provide a reasonable to_s" do
+      expect(@buffer.to_s).to eq("memory")
+    end
+
     it "should accept a buffer on input and use it directly" do
       s = "this is a test"
       @buffer = Thrift::MemoryBufferTransport.new(s)
-      @buffer.read(4).should == "this"
+      expect(@buffer.read(4)).to eq("this")
       s.slice!(-4..-1)
-      @buffer.read(@buffer.available).should == " is a "
+      expect(@buffer.read(@buffer.available)).to eq(" is a ")
     end
 
     it "should always remain open" do
-      @buffer.should be_open
+      expect(@buffer).to be_open
       @buffer.close
-      @buffer.should be_open
+      expect(@buffer).to be_open
     end
 
     it "should respond to peek and available" do
       @buffer.write "some data"
-      @buffer.peek.should be_true
-      @buffer.available.should == 9
+      expect(@buffer.peek).to be_truthy
+      expect(@buffer.available).to eq(9)
       @buffer.read(4)
-      @buffer.peek.should be_true
-      @buffer.available.should == 5
+      expect(@buffer.peek).to be_truthy
+      expect(@buffer.available).to eq(5)
       @buffer.read(5)
-      @buffer.peek.should be_false
-      @buffer.available.should == 0
+      expect(@buffer.peek).to be_falsey
+      expect(@buffer.available).to eq(0)
     end
 
     it "should be able to reset the buffer" do
       @buffer.write "test data"
       @buffer.reset_buffer("foobar")
-      @buffer.available.should == 6
-      @buffer.read(@buffer.available).should == "foobar"
+      expect(@buffer.available).to eq(6)
+      expect(@buffer.read(@buffer.available)).to eq("foobar")
       @buffer.reset_buffer
-      @buffer.available.should == 0
+      expect(@buffer.available).to eq(0)
     end
 
     it "should copy the given string when resetting the buffer" do
       s = "this is a test"
       @buffer.reset_buffer(s)
-      @buffer.available.should == 14
+      expect(@buffer.available).to eq(14)
       @buffer.read(10)
-      @buffer.available.should == 4
-      s.should == "this is a test"
+      expect(@buffer.available).to eq(4)
+      expect(s).to eq("this is a test")
     end
 
     it "should return from read what was given in write" do
       @buffer.write "test data"
-      @buffer.read(4).should == "test"
-      @buffer.read(@buffer.available).should == " data"
+      expect(@buffer.read(4)).to eq("test")
+      expect(@buffer.read(@buffer.available)).to eq(" data")
       @buffer.write "foo"
       @buffer.write " bar"
-      @buffer.read(@buffer.available).should == "foo bar"
+      expect(@buffer.read(@buffer.available)).to eq("foo bar")
     end
 
     it "should throw an EOFError when there isn't enough data in the buffer" do
       @buffer.reset_buffer("")
-      lambda{@buffer.read(1)}.should raise_error(EOFError)
+      expect{@buffer.read(1)}.to raise_error(EOFError)
 
       @buffer.reset_buffer("1234")
-      lambda{@buffer.read(5)}.should raise_error(EOFError)
+      expect{@buffer.read(5)}.to raise_error(EOFError)
     end
   end
 
   describe Thrift::IOStreamTransport do
     before(:each) do
-      @input = mock("Input", :closed? => false)
-      @output = mock("Output", :closed? => false)
+      @input = double("Input", :closed? => false)
+      @output = double("Output", :closed? => false)
       @trans = Thrift::IOStreamTransport.new(@input, @output)
     end
 
+    it "should provide a reasonable to_s" do
+      expect(@input).to receive(:to_s).and_return("mock_input")
+      expect(@output).to receive(:to_s).and_return("mock_output")
+      expect(@trans.to_s).to eq("iostream(input=mock_input,output=mock_output)")
+    end
+
     it "should be open as long as both input or output are open" do
-      @trans.should be_open
-      @input.stub!(:closed?).and_return(true)
-      @trans.should be_open
-      @input.stub!(:closed?).and_return(false)
-      @output.stub!(:closed?).and_return(true)
-      @trans.should be_open
-      @input.stub!(:closed?).and_return(true)
-      @trans.should_not be_open
+      expect(@trans).to be_open
+      allow(@input).to receive(:closed?).and_return(true)
+      expect(@trans).to be_open
+      allow(@input).to receive(:closed?).and_return(false)
+      allow(@output).to receive(:closed?).and_return(true)
+      expect(@trans).to be_open
+      allow(@input).to receive(:closed?).and_return(true)
+      expect(@trans).not_to be_open
     end
 
     it "should pass through read/write to input/output" do
-      @input.should_receive(:read).with(17).and_return("+ read")
-      @output.should_receive(:write).with("foobar").and_return("+ write")
-      @trans.read(17).should == "+ read"
-      @trans.write("foobar").should == "+ write"
+      expect(@input).to receive(:read).with(17).and_return("+ read")
+      expect(@output).to receive(:write).with("foobar").and_return("+ write")
+      expect(@trans.read(17)).to eq("+ read")
+      expect(@trans.write("foobar")).to eq("+ write")
     end
 
     it "should close both input and output when closed" do
-      @input.should_receive(:close)
-      @output.should_receive(:close)
+      expect(@input).to receive(:close)
+      expect(@output).to receive(:close)
       @trans.close
     end
   end