thrift 0.8.0 → 0.13.0

data/spec/server_spec.rb

@@ -16,144 +16,172 @@
 # specific language governing permissions and limitations
 # under the License.
 #
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
-class ThriftServerSpec < Spec::ExampleGroup
-  include Thrift
+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
 
-  describe BaseServer do
     it "should default to BaseTransportFactory and BinaryProtocolFactory when not specified" do
-      server = BaseServer.new(mock("Processor"), mock("BaseServerTransport"))
-      server.instance_variable_get(:'@transport_factory').should be_an_instance_of(BaseTransportFactory)
-      server.instance_variable_get(:'@protocol_factory').should be_an_instance_of(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
 
-  shared_examples_for "servers" do
+  describe Thrift::SimpleServer do
     before(:each) do
-      @processor = mock("Processor")
-      @serverTrans = mock("ServerTransport")
-      @trans = mock("BaseTransport")
-      @prot = mock("BaseProtocol")
-      @client = mock("Client")
-      @server = server_type.new(@processor, @serverTrans, @trans, @prot)
+      @processor = double("Processor")
+      @serverTrans = double("ServerTransport")
+      @trans = double("BaseTransport")
+      @prot = double("BaseProtocol")
+      @client = double("Client")
+      @server = described_class.new(@processor, @serverTrans, @trans, @prot)
     end
-  end
-
-  describe SimpleServer do
-    it_should_behave_like "servers"
-
-    def server_type
-      SimpleServer
+    
+    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 ThreadedServer do
-    it_should_behave_like "servers"
-
-    def server_type
-      ThreadedServer
+  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
-      @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 ThreadPoolServer do
-    it_should_behave_like "servers"
-
-    def server_type
-      # put this stuff here so it runs before the server is created
-      @threadQ = mock("SizedQueue")
-      SizedQueue.should_receive(:new).with(20).and_return(@threadQ)
-      @excQ = mock("Queue")
-      Queue.should_receive(:new).and_return(@excQ)
-      ThreadPoolServer
+  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 set up the queues" do
-      @server.instance_variable_get(:'@thread_q').should be(@threadQ)
-      @server.instance_variable_get(:'@exception_q').should be(@excQ)
+    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
-      Thread.should_receive(:new).and_return do |block|
-        @server.should_receive(:serve)
-        block.call
-        @server.rspec_verify
+      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
-      @excQ.should_receive(:pop).and_throw(:popped)
-      lambda { @server.rescuable_serve }.should throw_symbol(:popped)
+      expect { @server.rescuable_serve }.to(raise_error('ERROR'))
+      sleep(0.15)
     end
 
     it "should avoid running the server twice when retrying rescuable_serve" do
-      Thread.should_receive(:new).and_return do |block|
-        @server.should_receive(:serve)
-        block.call
-        @server.rspec_verify
+      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
-      @excQ.should_receive(:pop).twice.and_throw(:popped)
-      lambda { @server.rescuable_serve }.should throw_symbol(:popped)
-      lambda { @server.rescuable_serve }.should throw_symbol(:popped)
+      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
-      @serverTrans.should_receive(:listen).ordered
-      @threadQ.should_receive(:push).with(:token)
-      @threadQ.should_receive(:pop)
-      Thread.should_receive(:new).and_yield
-      @serverTrans.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)
+      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")
-      @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
-      @excQ.should_receive(:push).with(error).and_throw(:stop)
-      @serverTrans.should_receive(:close)
-      lambda { @server.serve }.should throw_symbol(:stop)
+      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

data/spec/socket_spec.rb

@@ -17,45 +17,52 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
 
-class ThriftSocketSpec < Spec::ExampleGroup
-  include Thrift
+describe 'Socket' do
 
-  describe Socket do
+  describe Thrift::Socket do
     before(:each) do
-      @socket = Socket.new
-      @handle = mock("Handle", :closed? => false)
-      @handle.stub!(:close)
-      @handle.stub!(:connect_nonblock)
-      ::Socket.stub!(:new).and_return(@handle)
+      @socket = Thrift::Socket.new
+      @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))
-      ::Socket.should_receive(:getaddrinfo).with("localhost", 9090).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))
-      ::Socket.should_receive(:getaddrinfo).with("my.domain", 1234).and_return([[]])
-      ::Socket.should_receive(:sockaddr_in)
-      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)
-      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

data/spec/socket_spec_shared.rb

@@ -17,88 +17,88 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
 shared_examples_for "a socket" do
   it "should open a socket" do
-    @socket.open.should == @handle
+    expect(@socket.open).to eq(@handle)
   end
 
   it "should be open whenever it has a handle" do
-    @socket.should_not be_open
+    expect(@socket).not_to be_open
     @socket.open
-    @socket.should be_open
+    expect(@socket).to be_open
     @socket.handle = nil
-    @socket.should_not be_open
+    expect(@socket).not_to be_open
     @socket.handle = @handle
     @socket.close
-    @socket.should_not be_open
+    expect(@socket).not_to be_open
   end
 
   it "should write data to the handle" do
     @socket.open
-    @handle.should_receive(:write).with("foobar")
+    expect(@handle).to receive(:write).with("foobar")
     @socket.write("foobar")
-    @handle.should_receive(:write).with("fail").and_raise(StandardError)
-    lambda { @socket.write("fail") }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+    expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
+    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
   end
 
   it "should raise an error when it cannot read from the handle" do
     @socket.open
-    @handle.should_receive(:readpartial).with(17).and_raise(StandardError)
-    lambda { @socket.read(17) }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+    expect(@handle).to receive(:readpartial).with(17).and_raise(StandardError)
+    expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
   end
 
   it "should return the data read when reading from the handle works" do
     @socket.open
-    @handle.should_receive(:readpartial).with(17).and_return("test data")
-    @socket.read(17).should == "test data"
+    expect(@handle).to receive(:readpartial).with(17).and_return("test data")
+    expect(@socket.read(17)).to eq("test data")
   end
 
   it "should declare itself as closed when it has an error" do
     @socket.open
-    @handle.should_receive(:write).with("fail").and_raise(StandardError)
-    @socket.should be_open
-    lambda { @socket.write("fail") }.should raise_error
-    @socket.should_not be_open
+    expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
+    expect(@socket).to be_open
+    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
+    expect(@socket).not_to be_open
   end
 
   it "should raise an error when the stream is closed" do
     @socket.open
-    @handle.stub!(:closed?).and_return(true)
-    @socket.should_not be_open
-    lambda { @socket.write("fail") }.should raise_error(IOError, "closed stream")
-    lambda { @socket.read(10) }.should raise_error(IOError, "closed stream")
+    allow(@handle).to receive(:closed?).and_return(true)
+    expect(@socket).not_to be_open
+    expect { @socket.write("fail") }.to raise_error(IOError, "closed stream")
+    expect { @socket.read(10) }.to raise_error(IOError, "closed stream")
   end
 
   it "should support the timeout accessor for read" do
     @socket.timeout = 3
     @socket.open
-    IO.should_receive(:select).with([@handle], nil, nil, 3).and_return([[@handle], [], []])
-    @handle.should_receive(:readpartial).with(17).and_return("test data")
-    @socket.read(17).should == "test data"
+    expect(IO).to receive(:select).with([@handle], nil, nil, 3).and_return([[@handle], [], []])
+    expect(@handle).to receive(:readpartial).with(17).and_return("test data")
+    expect(@socket.read(17)).to eq("test data")
   end
 
   it "should support the timeout accessor for write" do
     @socket.timeout = 3
     @socket.open
-    IO.should_receive(:select).with(nil, [@handle], nil, 3).twice.and_return([[], [@handle], []])
-    @handle.should_receive(:write_nonblock).with("test data").and_return(4)
-    @handle.should_receive(:write_nonblock).with(" data").and_return(5)
-    @socket.write("test data").should == 9
+    expect(IO).to receive(:select).with(nil, [@handle], nil, 3).twice.and_return([[], [@handle], []])
+    expect(@handle).to receive(:write_nonblock).with("test data").and_return(4)
+    expect(@handle).to receive(:write_nonblock).with(" data").and_return(5)
+    expect(@socket.write("test data")).to eq(9)
   end
 
   it "should raise an error when read times out" do
     @socket.timeout = 0.5
     @socket.open
-    IO.should_receive(:select).once {sleep(0.5); nil}
-    lambda { @socket.read(17) }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::TIMED_OUT }
+    expect(IO).to receive(:select).once {sleep(0.5); nil}
+    expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
   end
 
   it "should raise an error when write times out" do
     @socket.timeout = 0.5
     @socket.open
-    IO.should_receive(:select).with(nil, [@handle], nil, 0.5).any_number_of_times.and_return(nil)
-    lambda { @socket.write("test data") }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::TIMED_OUT }
+    allow(IO).to receive(:select).with(nil, [@handle], nil, 0.5).and_return(nil)
+    expect { @socket.write("test data") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements. See the NOTICE file
@@ -18,7 +19,7 @@
 #
 
 require 'rubygems'
-require 'spec'
+require 'rspec'
 
 $:.unshift File.join(File.dirname(__FILE__), *%w[.. ext])
 
@@ -26,33 +27,38 @@ $:.unshift File.join(File.dirname(__FILE__), *%w[.. ext])
 # will get screwed up
 # $" << 'fastthread.bundle'
 
-require File.dirname(__FILE__) + '/../lib/thrift'
+require 'thrift'
 
-class Object
-  # tee is a useful method, so let's let our tests have it
-  def tee(&block)
-    block.call(self)
-    self
+unless Object.method_defined? :tap
+  # if Object#tap isn't defined, then add it; this should only happen in Ruby < 1.8.7
+  class Object
+    def tap(&block)
+      block.call(self)
+      self
+    end
   end
 end
 
-Spec::Runner.configure do |configuration|
+RSpec.configure do |configuration|
   configuration.before(:each) do
     Thrift.type_checking = true
   end
 end
 
 $:.unshift File.join(File.dirname(__FILE__), *%w[.. test debug_proto gen-rb])
-require "srv"
-require "debug_proto_test_constants"
+require 'srv'
+require 'debug_proto_test_constants'
 
 $:.unshift File.join(File.dirname(__FILE__), *%w[gen-rb])
 require 'thrift_spec_types'
 require 'nonblocking_service'
 
 module Fixtures
-  COMPACT_PROTOCOL_TEST_STRUCT = COMPACT_TEST.dup
+  COMPACT_PROTOCOL_TEST_STRUCT = Thrift::Test::COMPACT_TEST.dup
   COMPACT_PROTOCOL_TEST_STRUCT.a_binary = [0,1,2,3,4,5,6,7,8].pack('c*')
   COMPACT_PROTOCOL_TEST_STRUCT.set_byte_map = nil
   COMPACT_PROTOCOL_TEST_STRUCT.map_byte_map = nil
 end
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[gen-rb/flat])
+