upfluence-thrift 2.6.1 → 2.7.4

data/spec/processor_spec.rb

@@ -20,59 +20,70 @@
 require 'spec_helper'
 
 describe 'Processor' do
-
   class ProcessorSpec
     include Thrift::Processor
   end
 
   describe Thrift::Processor do
     before(:each) do
-      @processor = ProcessorSpec.new(mock("MockHandler"))
-      @prot = mock("MockProtocol")
+      @processor = ProcessorSpec.new(double('MockHandler'))
+      @prot = double('MockProtocol')
     end
 
     def mock_trans(obj)
-      obj.should_receive(:trans).ordered.and_return do
-        mock("trans").tap do |trans|
-          trans.should_receive(:flush).ordered
+      expect(obj).to receive(:trans).ordered do
+        double('trans').tap do |trans|
+          expect(trans).to receive(:flush).ordered
         end
       end
     end
 
-    it "should call process_<message> when it receives that message" do
-      @prot.should_receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 17]
-      @processor.should_receive(:process_testMessage).with(17, @prot, @prot).ordered
-      @processor.process(@prot, @prot).should == true
+    it 'should call process_<message> when it receives that message' do
+      expect(@prot).to receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 17]
+      expect(@processor).to receive(:process_testMessage).with(17, @prot, @prot).ordered
+      expect(@processor.process(@prot, @prot)).to eq(true)
     end
 
-    xit "should raise an ApplicationException when the received message cannot be processed" do
-      @prot.should_receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 4]
-      @prot.should_receive(:skip).with(Thrift::Types::STRUCT).ordered
-      @prot.should_receive(:read_message_end).ordered
-      @prot.should_receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::EXCEPTION, 4).ordered
-      e = mock(Thrift::ApplicationException)
-      e.should_receive(:write).with(@prot).ordered
-      Thrift::ApplicationException.should_receive(:new).with(Thrift::ApplicationException::UNKNOWN_METHOD, "Unknown function testMessage").and_return(e)
-      @prot.should_receive(:write_message_end).ordered
+    it 'should raise an ApplicationException when the received message cannot be processed' do
+      expect(@prot).to receive(:read_message_begin).ordered.and_return ['testMessage', Thrift::MessageTypes::CALL, 4]
+      expect(@prot).to receive(:skip).with(Thrift::Types::STRUCT).ordered
+      expect(@prot).to receive(:read_message_end).ordered
+      expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::EXCEPTION, 4).ordered
+      e = Thrift::ApplicationException.new(
+        Thrift::ApplicationException::UNKNOWN_METHOD,
+        'Unknown function testMessage'
+      )
+      expect(Thrift::ApplicationException).to receive(:new).with(Thrift::ApplicationException::UNKNOWN_METHOD,
+                                                                 'Unknown function testMessage').and_return(e)
+      expect(@prot).to receive(:write_struct_begin).with('Thrift::ApplicationException').ordered
+      expect(@prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1).ordered
+      expect(@prot).to receive(:write_string).with('Unknown function testMessage').ordered
+      expect(@prot).to receive(:write_field_end).ordered
+      expect(@prot).to receive(:write_field_begin).with('type', Thrift::Types::I32, 2).ordered
+      expect(@prot).to receive(:write_i32).with(Thrift::ApplicationException::UNKNOWN_METHOD).ordered
+      expect(@prot).to receive(:write_field_end).ordered
+      expect(@prot).to receive(:write_field_stop).ordered
+      expect(@prot).to receive(:write_struct_end).ordered
+      expect(@prot).to receive(:write_message_end).ordered
       mock_trans(@prot)
       @processor.process(@prot, @prot)
     end
 
-    it "should pass args off to the args class" do
-      args_class = mock("MockArgsClass")
-      args = mock("#<MockArgsClass:mock>").tap do |args|
-        args.should_receive(:read).with(@prot).ordered
+    it 'should pass args off to the args class' do
+      args_class = double('MockArgsClass')
+      args = double('#<MockArgsClass:mock>').tap do |args|
+        expect(args).to receive(:read).with(@prot).ordered
       end
-      args_class.should_receive(:new).and_return args
-      @prot.should_receive(:read_message_end).ordered
-      @processor.read_args(@prot, args_class).should eql(args)
+      expect(args_class).to receive(:new).and_return args
+      expect(@prot).to receive(:read_message_end).ordered
+      expect(@processor.read_args(@prot, args_class)).to eql(args)
     end
 
-    it "should write out a reply when asked" do
-      @prot.should_receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::REPLY, 23).ordered
-      result = mock("MockResult")
-      result.should_receive(:write).with(@prot).ordered
-      @prot.should_receive(:write_message_end).ordered
+    it 'should write out a reply when asked' do
+      expect(@prot).to receive(:write_message_begin).with('testMessage', Thrift::MessageTypes::REPLY, 23).ordered
+      result = double('MockResult')
+      expect(result).to receive(:write).with(@prot).ordered
+      expect(@prot).to receive(:write_message_end).ordered
       mock_trans(@prot)
       @processor.write_result(result, @prot, 'testMessage', 23)
     end

data/spec/rack_application_spec.rb

@@ -25,53 +25,49 @@ require 'thrift/server/rack_application'
 describe Thrift::RackApplication do
   include Rack::Test::Methods
 
-  let(:processor) { mock('processor') }
-  let(:protocol_factory) { mock('protocol factory') }
+  let(:processor) { double('processor') }
+  let(:protocol_factory) { double('protocol factory') }
 
   def app
-    Thrift::RackApplication.for("/", processor, protocol_factory)
+    Thrift::RackApplication.for('/', processor, protocol_factory)
   end
 
-  context "404 response" do
-
+  context '404 response' do
     it 'receives a non-POST' do
-      header('Content-Type', "application/x-thrift")
-      get "/"
-      last_response.status.should be 404
+      header('Content-Type', 'application/x-thrift')
+      get '/'
+      expect(last_response.status).to be 404
     end
 
     it 'receives a header other than application/x-thrift' do
-      header('Content-Type', "application/json")
-      post "/"
-      last_response.status.should be 404
+      header('Content-Type', 'application/json')
+      post '/'
+      expect(last_response.status).to be 404
     end
-
   end
 
-  context "200 response" do
-
+  context '200 response' do
     before do
-      protocol_factory.stub(:get_protocol)
-      processor.stub(:process)
+      allow(protocol_factory).to receive(:get_protocol)
+      allow(processor).to receive(:process)
     end
 
     it 'creates an IOStreamTransport' do
-      header('Content-Type', "application/x-thrift")
-      Thrift::IOStreamTransport.should_receive(:new).with(an_instance_of(StringIO), an_instance_of(Rack::Response))
-      post "/"
+      header('Content-Type', 'application/x-thrift')
+      expect(Thrift::IOStreamTransport).to receive(:new).with(an_instance_of(StringIO), an_instance_of(Rack::Response))
+      post '/'
     end
 
     it 'fetches the right protocol based on the Transport' do
-      header('Content-Type', "application/x-thrift")
-      protocol_factory.should_receive(:get_protocol).with(an_instance_of(Thrift::IOStreamTransport))
-      post "/"
+      header('Content-Type', 'application/x-thrift')
+      expect(protocol_factory).to receive(:get_protocol).with(an_instance_of(Thrift::IOStreamTransport))
+      post '/'
     end
 
     it 'status code 200' do
-      header('Content-Type', "application/x-thrift")
-      post "/"
-      last_response.ok?.should be_true
+      header('Content-Type', 'application/x-thrift')
+      post '/'
+      expect(last_response.ok?).to be_truthy
     end
-
   end
 end

data/spec/serializer_spec.rb

@@ -25,19 +25,19 @@ describe '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!"))
-      data.should == "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
+      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(mock("transport"))
-      protocol.should_receive(:write_struct_begin).with("SpecNamespace::Hello")
-      protocol.should_receive(:write_field_begin).with("greeting", Thrift::Types::STRING, 1)
-      protocol.should_receive(:write_string).with("Good day")
-      protocol.should_receive(:write_field_end)
-      protocol.should_receive(:write_field_stop)
-      protocol.should_receive(:write_struct_end)
-      protocol_factory = mock("ProtocolFactory")
-      protocol_factory.stub!(:get_protocol).and_return(protocol)
+      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
@@ -47,21 +47,21 @@ describe 'Serializer' 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"
-      deserializer.deserialize(SpecNamespace::Hello.new, data).should == SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!")
+      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(mock("transport"))
-      protocol.should_receive(:read_struct_begin).and_return("SpecNamespace::Hello")
-      protocol.should_receive(:read_field_begin).and_return(["greeting", Thrift::Types::STRING, 1],
+      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])
-      protocol.should_receive(:read_string).and_return("Good day")
-      protocol.should_receive(:read_field_end)
-      protocol.should_receive(:read_struct_end)
-      protocol_factory = mock("ProtocolFactory")
-      protocol_factory.stub!(:get_protocol).and_return(protocol)
+      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)
-      deserializer.deserialize(SpecNamespace::Hello.new, "").should == SpecNamespace::Hello.new(:greeting => "Good day")
+      expect(deserializer.deserialize(SpecNamespace::Hello.new, "")).to eq(SpecNamespace::Hello.new(:greeting => "Good day"))
     end
   end
 end

data/spec/server_socket_spec.rb

@@ -28,52 +28,57 @@ describe 'Thrift::ServerSocket' do
     end
 
     it "should create a handle when calling listen" do
-      TCPServer.should_receive(:new).with(nil, 1234)
+      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)
-      TCPServer.should_receive(:new).with('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 = mock("TCPServer")
-      TCPServer.should_receive(:new).with(nil, 1234).and_return(handle)
+      handle = double("TCPServer")
+      expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
       @socket.listen
-      sock = mock("sock")
-      handle.should_receive(:accept).and_return(sock)
-      trans = mock("Socket")
-      Thrift::Socket.should_receive(:new).and_return(trans)
-      trans.should_receive(:handle=).with(sock)
-      @socket.accept.should == trans
+      sock = double("sock")
+      expect(handle).to receive(:accept).and_return(sock)
+      trans = double("Socket")
+      expect(Thrift::Socket).to receive(:new).and_return(trans)
+      expect(trans).to receive(:handle=).with(sock)
+      expect(@socket.accept).to eq(trans)
     end
 
     it "should close the handle when closed" do
-      handle = mock("TCPServer", :closed? => false)
-      TCPServer.should_receive(:new).with(nil, 1234).and_return(handle)
+      handle = double("TCPServer", :closed? => false)
+      expect(TCPServer).to receive(:new).with(nil, 1234).and_return(handle)
       @socket.listen
-      handle.should_receive(:close)
+      expect(handle).to receive(:close)
       @socket.close
     end
 
     it "should return nil when accepting if there is no handle" do
-      @socket.accept.should be_nil
+      expect(@socket.accept).to be_nil
     end
 
     it "should return true for closed? when appropriate" do
-      handle = mock("TCPServer", :closed? => false)
-      TCPServer.stub!(:new).and_return(handle)
+      handle = double("TCPServer", :closed? => false)
+      allow(TCPServer).to receive(:new).and_return(handle)
       @socket.listen
-      @socket.should_not be_closed
-      handle.stub!(:close)
+      expect(@socket).not_to be_closed
+      allow(handle).to receive(:close)
       @socket.close
-      @socket.should be_closed
+      expect(@socket).to be_closed
       @socket.listen
-      @socket.should_not be_closed
-      handle.stub!(:closed?).and_return(true)
-      @socket.should be_closed
+      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

@@ -21,95 +21,135 @@ require 'spec_helper'
 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(mock("Processor"), mock("BaseServerTransport"))
-      server.instance_variable_get(:'@transport_factory').should be_an_instance_of(Thrift::BaseTransportFactory)
-      server.instance_variable_get(:'@protocol_factory').should be_an_instance_of(Thrift::BinaryProtocolFactory)
+      @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
 
-    # serve is a noop, so can't test that
+    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 = mock("Processor")
-      @serverTrans = mock("ServerTransport")
-      @trans = mock("BaseTransport")
-      @prot = mock("BaseProtocol")
-      @client = mock("Client")
+      @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
-      @serverTrans.should_receive(:listen).ordered
-      @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
-      @trans.should_receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
-      @prot.should_receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
+      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
-      @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
+      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
-      @trans.should_receive(:close).exactly(3).times
-      @serverTrans.should_receive(:close).ordered
-      lambda { @server.serve }.should throw_symbol(:stop)
+      expect(@trans).to receive(:close).exactly(3).times
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
     end
   end
 
   describe Thrift::ThreadedServer do
     before(:each) do
-      @processor = mock("Processor")
-      @serverTrans = mock("ServerTransport")
-      @trans = mock("BaseTransport")
-      @prot = mock("BaseProtocol")
-      @client = mock("Client")
+      @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
-      @serverTrans.should_receive(:listen).ordered
-      @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
-      @trans.should_receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
-      @prot.should_receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
-      Thread.should_receive(:new).with(@prot, @trans).exactly(3).times.and_yield(@prot, @trans)
+      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
-      @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
+      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
-      @trans.should_receive(:close).exactly(3).times
-      @serverTrans.should_receive(:close).ordered
-      lambda { @server.serve }.should throw_symbol(:stop)
+      expect(@trans).to receive(:close).exactly(3).times
+      expect(@serverTrans).to receive(:close).ordered
+      expect { @server.serve }.to throw_symbol(:stop)
     end
   end
 
   describe Thrift::ThreadPoolServer do
     before(:each) do
-      @processor = mock("Processor")
-      @server_trans = mock("ServerTransport")
-      @trans = mock("BaseTransport")
-      @prot = mock("BaseProtocol")
-      @client = mock("Client")
+      @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)
-      described_class.any_instance.should_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'))
+      sleep(0.15)
     end
 
     it "should avoid running the server twice when retrying rescuable_serve" do
       exception_q = @server.instance_variable_get(:@exception_q)
-      described_class.any_instance.should_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
@@ -118,29 +158,29 @@ describe 'Server' do
     end
 
     it "should serve using a thread pool" do
-      thread_q = mock("SizedQueue")
-      exception_q = mock("Queue")
+      thread_q = double("SizedQueue")
+      exception_q = double("Queue")
       @server.instance_variable_set(:@thread_q, thread_q)
       @server.instance_variable_set(:@exception_q, exception_q)
-      @server_trans.should_receive(:listen).ordered
-      thread_q.should_receive(:push).with(:token)
-      thread_q.should_receive(:pop)
-      Thread.should_receive(:new).and_yield
-      @server_trans.should_receive(:accept).exactly(3).times.and_return(@client)
-      @trans.should_receive(:get_transport).exactly(3).times.and_return(@trans)
-      @prot.should_receive(:get_protocol).exactly(3).times.and_return(@prot)
+      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")
-      @processor.should_receive(:process).exactly(3).times.with(@prot, @prot).and_return do
+      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
-      @trans.should_receive(:close).exactly(3).times
-      exception_q.should_receive(:push).with(error).and_throw(:stop)
-      @server_trans.should_receive(:close)
+      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

data/spec/socket_spec.rb

@@ -25,37 +25,44 @@ describe 'Socket' do
   describe Thrift::Socket do
     before(:each) do
       @socket = Thrift::Socket.new
-      @handle = mock("Handle", :closed? => false)
-      @handle.stub!(:close)
-      @handle.stub!(:connect_nonblock)
-      @handle.stub!(:setsockopt)
-      ::Socket.stub!(:new).and_return(@handle)
+      @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)
     end
 
     it_should_behave_like "a socket"
 
     it "should raise a TransportException when it cannot open a socket" do
-      ::Socket.should_receive(:new).and_raise(StandardError)
-      lambda { @socket.open }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+      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) }
     end
 
     it "should open a ::Socket with default args" do
-      ::Socket.should_receive(:new).and_return(mock("Handle", :connect_nonblock => true, :setsockopt => nil))
-      ::Socket.should_receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      ::Socket.should_receive(:sockaddr_in)
+      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)
+      @socket.to_s == "socket(localhost:9090)"
       @socket.open
     end
 
     it "should accept host/port options" do
-      ::Socket.should_receive(:new).and_return(mock("Handle", :connect_nonblock => true, :setsockopt => nil))
-      ::Socket.should_receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      ::Socket.should_receive(:sockaddr_in)
-      Thrift::Socket.new('my.domain', 1234).open
+      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)
+      @socket = Thrift::Socket.new('my.domain', 1234).open
+      @socket.to_s == "socket(my.domain:1234)"
     end
 
     it "should accept an optional timeout" do
-      ::Socket.stub!(:new)
-      Thrift::Socket.new('localhost', 8080, 5).timeout.should == 5
+      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
   end
 end