thrift 0.8.0 → 0.9.0

data/spec/mongrel_http_server_spec.rb

@@ -17,65 +17,62 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 require 'thrift/server/mongrel_http_server'
 
-class ThriftHTTPServerSpec < Spec::ExampleGroup
-  include Thrift
+describe 'HTTPServer' do
 
-  Handler = MongrelHTTPServer::Handler
-
-  describe MongrelHTTPServer do
+  describe Thrift::MongrelHTTPServer do
     it "should have appropriate defaults" do
       mock_factory = mock("BinaryProtocolFactory")
       mock_proc = mock("Processor")
-      BinaryProtocolFactory.should_receive(:new).and_return(mock_factory)
+      Thrift::BinaryProtocolFactory.should_receive(:new).and_return(mock_factory)
       Mongrel::HttpServer.should_receive(:new).with("0.0.0.0", 80).and_return do
-        mock("Mongrel::HttpServer").tee do |mock|
+        mock("Mongrel::HttpServer").tap do |mock|
           handler = mock("Handler")
-          Handler.should_receive(:new).with(mock_proc, mock_factory).and_return(handler)
+          Thrift::MongrelHTTPServer::Handler.should_receive(:new).with(mock_proc, mock_factory).and_return(handler)
           mock.should_receive(:register).with("/", handler)
         end
       end
-      MongrelHTTPServer.new(mock_proc)
+      Thrift::MongrelHTTPServer.new(mock_proc)
     end
 
     it "should understand :ip, :port, :path, and :protocol_factory" do
       mock_proc = mock("Processor")
       mock_factory = mock("ProtocolFactory")
       Mongrel::HttpServer.should_receive(:new).with("1.2.3.4", 1234).and_return do
-        mock("Mongrel::HttpServer").tee do |mock|
+        mock("Mongrel::HttpServer").tap do |mock|
           handler = mock("Handler")
-          Handler.should_receive(:new).with(mock_proc, mock_factory).and_return(handler)
+          Thrift::MongrelHTTPServer::Handler.should_receive(:new).with(mock_proc, mock_factory).and_return(handler)
           mock.should_receive(:register).with("/foo", handler)
         end
       end
-      MongrelHTTPServer.new(mock_proc, :ip => "1.2.3.4", :port => 1234, :path => "foo",
+      Thrift::MongrelHTTPServer.new(mock_proc, :ip => "1.2.3.4", :port => 1234, :path => "foo",
                                              :protocol_factory => mock_factory)
     end
 
     it "should serve using Mongrel::HttpServer" do
-      BinaryProtocolFactory.stub!(:new)
+      Thrift::BinaryProtocolFactory.stub!(:new)
       Mongrel::HttpServer.should_receive(:new).and_return do
-        mock("Mongrel::HttpServer").tee do |mock|
-          Handler.stub!(:new)
+        mock("Mongrel::HttpServer").tap do |mock|
+          Thrift::MongrelHTTPServer::Handler.stub!(:new)
           mock.stub!(:register)
           mock.should_receive(:run).and_return do
-            mock("Mongrel::HttpServer.run").tee do |runner|
+            mock("Mongrel::HttpServer.run").tap do |runner|
               runner.should_receive(:join)
             end
           end
         end
       end
-      MongrelHTTPServer.new(nil).serve
+      Thrift::MongrelHTTPServer.new(nil).serve
     end
   end
 
-  describe MongrelHTTPServer::Handler do
+  describe Thrift::MongrelHTTPServer::Handler do
     before(:each) do
       @processor = mock("Processor")
       @factory = mock("ProtocolFactory")
-      @handler = Handler.new(@processor, @factory)
+      @handler = described_class.new(@processor, @factory)
     end
 
     it "should return 404 for non-POST requests" do
@@ -91,7 +88,7 @@ class ThriftHTTPServerSpec < Spec::ExampleGroup
       response = mock("response")
       head = mock("head")
       head.should_receive(:[]=).with("Content-Type", "application/x-thrift")
-      IOStreamTransport.stub!(:new)
+      Thrift::IOStreamTransport.stub!(:new)
       @factory.stub!(:get_protocol)
       @processor.stub!(:process)
       response.should_receive(:start).with(200).and_yield(head, nil)
@@ -107,7 +104,7 @@ class ThriftHTTPServerSpec < Spec::ExampleGroup
       out = mock("out")
       protocol = mock("protocol")
       transport = mock("transport")
-      IOStreamTransport.should_receive(:new).with(body, out).and_return(transport)
+      Thrift::IOStreamTransport.should_receive(:new).with(body, out).and_return(transport)
       @factory.should_receive(:get_protocol).with(transport).and_return(protocol)
       @processor.should_receive(:process).with(protocol, protocol)
       response.should_receive(:start).with(200).and_yield(head, out)

data/spec/nonblocking_server_spec.rb

@@ -17,11 +17,9 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
-class ThriftNonblockingServerSpec < Spec::ExampleGroup
-  include Thrift
-  include SpecNamespace
+describe 'NonblockingServer' do
 
   class Handler
     def initialize
@@ -55,7 +53,7 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
     end
   end
 
-  class SpecTransport < BaseTransport
+  class SpecTransport < Thrift::BaseTransport
     def initialize(transport, queue)
       @transport = transport
       @queue = queue
@@ -89,7 +87,7 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
     end
   end
 
-  class SpecServerSocket < ServerSocket
+  class SpecServerSocket < Thrift::ServerSocket
     def initialize(host, port, queue)
       super(host, port)
       @queue = queue
@@ -105,13 +103,13 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
     before(:each) do
       @port = 43251
       handler = Handler.new
-      processor = NonblockingService::Processor.new(handler)
+      processor = SpecNamespace::NonblockingService::Processor.new(handler)
       queue = Queue.new
       @transport = SpecServerSocket.new('localhost', @port, queue)
-      transport_factory = FramedTransportFactory.new
+      transport_factory = Thrift::FramedTransportFactory.new
       logger = Logger.new(STDERR)
       logger.level = Logger::WARN
-      @server = NonblockingServer.new(processor, @transport, transport_factory, nil, 5, logger)
+      @server = Thrift::NonblockingServer.new(processor, @transport, transport_factory, nil, 5, logger)
       handler.server = @server
       @server_thread = Thread.new(Thread.current) do |master_thread|
         begin
@@ -136,9 +134,9 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
     end
 
     def setup_client(queue = nil)
-      transport = SpecTransport.new(FramedTransport.new(Socket.new('localhost', @port)), queue)
-      protocol = BinaryProtocol.new(transport)
-      client = NonblockingService::Client.new(protocol)
+      transport = SpecTransport.new(Thrift::FramedTransport.new(Thrift::Socket.new('localhost', @port)), queue)
+      protocol = Thrift::BinaryProtocol.new(transport)
+      client = SpecNamespace::NonblockingService::Client.new(protocol)
       transport.open
       @clients << [client, transport]
       client
@@ -178,8 +176,8 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
 
     it "should handle basic message passing" do
       client = setup_client
-      client.greeting(true).should == Hello.new
-      client.greeting(false).should == Hello.new(:greeting => 'Aloha!')
+      client.greeting(true).should == SpecNamespace::Hello.new
+      client.greeting(false).should == SpecNamespace::Hello.new(:greeting => 'Aloha!')
       @server.shutdown
     end
 
@@ -214,15 +212,15 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
       queues[4] << :hello
       queues[5] << :hello
       queues[6] << :hello
-      3.times { result.pop.should == Hello.new }
-      client.greeting(true).should == Hello.new
+      3.times { result.pop.should == SpecNamespace::Hello.new }
+      client.greeting(true).should == SpecNamespace::Hello.new
       queues[5] << [:unblock, 4]
       4.times { result.pop.should be_true }
       queues[2] << :hello
-      result.pop.should == Hello.new
-      client.greeting(false).should == Hello.new(:greeting => 'Aloha!')
+      result.pop.should == SpecNamespace::Hello.new
+      client.greeting(false).should == SpecNamespace::Hello.new(:greeting => 'Aloha!')
       7.times { queues.shift << :exit }
-      client.greeting(true).should == Hello.new
+      client.greeting(true).should == SpecNamespace::Hello.new
       @server.shutdown
     end
 
@@ -257,7 +255,7 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
 
     it "should allow shutting down in response to a message" do
       client = setup_client
-      client.greeting(true).should == Hello.new
+      client.greeting(true).should == SpecNamespace::Hello.new
       client.shutdown
       @server_thread.join(2).should_not be_nil
     end

data/spec/processor_spec.rb

@@ -17,16 +17,15 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
-class ThriftProcessorSpec < Spec::ExampleGroup
-  include Thrift
+describe 'Processor' do
 
   class ProcessorSpec
     include Thrift::Processor
   end
 
-  describe "Processor" do
+  describe Thrift::Processor do
     before(:each) do
       @processor = ProcessorSpec.new(mock("MockHandler"))
       @prot = mock("MockProtocol")
@@ -34,28 +33,26 @@ class ThriftProcessorSpec < Spec::ExampleGroup
 
     def mock_trans(obj)
       obj.should_receive(:trans).ordered.and_return do
-        mock("trans").tee do |trans|
+        mock("trans").tap do |trans|
           trans.should_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', MessageTypes::CALL, 17]
+      @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
     end
 
     it "should raise an ApplicationException when the received message cannot be processed" do
-      @prot.should_receive(:read_message_begin).ordered.and_return ['testMessage', MessageTypes::CALL, 4]
-      @prot.should_receive(:skip).with(Types::STRUCT).ordered
+      @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', MessageTypes::EXCEPTION, 4).ordered
-      ApplicationException.should_receive(:new).with(ApplicationException::UNKNOWN_METHOD, "Unknown function testMessage").and_return do
-        mock(ApplicationException).tee do |e|
-          e.should_receive(:write).with(@prot).ordered
-        end
-      end
+      @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
       mock_trans(@prot)
       @processor.process(@prot, @prot)
@@ -63,7 +60,7 @@ class ThriftProcessorSpec < Spec::ExampleGroup
 
     it "should pass args off to the args class" do
       args_class = mock("MockArgsClass")
-      args = mock("#<MockArgsClass:mock>").tee do |args|
+      args = mock("#<MockArgsClass:mock>").tap do |args|
         args.should_receive(:read).with(@prot).ordered
       end
       args_class.should_receive(:new).and_return args
@@ -72,7 +69,7 @@ class ThriftProcessorSpec < Spec::ExampleGroup
     end
 
     it "should write out a reply when asked" do
-      @prot.should_receive(:write_message_begin).with('testMessage', MessageTypes::REPLY, 23).ordered
+      @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

data/spec/serializer_spec.rb

@@ -17,53 +17,51 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
-class ThriftSerializerSpec < Spec::ExampleGroup
-  include Thrift
-  include SpecNamespace
+describe 'Serializer' do
 
-  describe Serializer do
+  describe Thrift::Serializer do
     it "should serialize structs to binary by default" do
-      serializer = Serializer.new(Thrift::BinaryProtocolAcceleratedFactory.new)
-      data = serializer.serialize(Hello.new(:greeting => "'Ello guv'nor!"))
+      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"
     end
 
     it "should serialize structs to the given protocol" do
-      protocol = BaseProtocol.new(mock("transport"))
+      protocol = Thrift::BaseProtocol.new(mock("transport"))
       protocol.should_receive(:write_struct_begin).with("SpecNamespace::Hello")
-      protocol.should_receive(:write_field_begin).with("greeting", Types::STRING, 1)
+      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)
-      serializer = Serializer.new(protocol_factory)
-      serializer.serialize(Hello.new(:greeting => "Good day"))
+      serializer = Thrift::Serializer.new(protocol_factory)
+      serializer.serialize(SpecNamespace::Hello.new(:greeting => "Good day"))
     end
   end
 
-  describe Deserializer do
+  describe Thrift::Deserializer do
     it "should deserialize structs from binary by default" do
-      deserializer = Deserializer.new
+      deserializer = Thrift::Deserializer.new
       data = "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
-      deserializer.deserialize(Hello.new, data).should == Hello.new(:greeting => "'Ello guv'nor!")
+      deserializer.deserialize(SpecNamespace::Hello.new, data).should == SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!")
     end
 
     it "should deserialize structs from the given protocol" do
-      protocol = BaseProtocol.new(mock("transport"))
+      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", Types::STRING, 1],
-                                                            [nil, Types::STOP, 0])
+      protocol.should_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)
-      deserializer = Deserializer.new(protocol_factory)
-      deserializer.deserialize(Hello.new, "").should == Hello.new(:greeting => "Good day")
+      deserializer = Thrift::Deserializer.new(protocol_factory)
+      deserializer.deserialize(SpecNamespace::Hello.new, "").should == SpecNamespace::Hello.new(:greeting => "Good day")
     end
   end
 end

data/spec/server_socket_spec.rb

@@ -17,15 +17,14 @@
 # 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 ThriftServerSocketSpec < Spec::ExampleGroup
-  include Thrift
+describe 'Thrift::ServerSocket' do
 
-  describe ServerSocket do
+  describe Thrift::ServerSocket do
     before(:each) do
-      @socket = ServerSocket.new(1234)
+      @socket = Thrift::ServerSocket.new(1234)
     end
 
     it "should create a handle when calling listen" do
@@ -34,7 +33,7 @@ class ThriftServerSocketSpec < Spec::ExampleGroup
     end
 
     it "should accept an optional host argument" do
-      @socket = ServerSocket.new('localhost', 1234)
+      @socket = Thrift::ServerSocket.new('localhost', 1234)
       TCPServer.should_receive(:new).with('localhost', 1234)
       @socket.listen
     end
@@ -46,7 +45,7 @@ class ThriftServerSocketSpec < Spec::ExampleGroup
       sock = mock("sock")
       handle.should_receive(:accept).and_return(sock)
       trans = mock("Socket")
-     Socket.should_receive(:new).and_return(trans)
+      Thrift::Socket.should_receive(:new).and_return(trans)
       trans.should_receive(:handle=).with(sock)
       @socket.accept.should == trans
     end

data/spec/server_spec.rb

@@ -16,39 +16,30 @@
 # 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 BaseServer do
+  describe Thrift::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(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)
     end
 
     # serve is a noop, so can't test that
   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)
+      @server = described_class.new(@processor, @serverTrans, @trans, @prot)
     end
-  end
-
-  describe SimpleServer do
-    it_should_behave_like "servers"
-
-    def server_type
-      SimpleServer
-    end
-
+    
     it "should serve in the main thread" do
       @serverTrans.should_receive(:listen).ordered
       @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
@@ -68,11 +59,14 @@ class ThriftServerSpec < Spec::ExampleGroup
     end
   end
 
-  describe ThreadedServer do
-    it_should_behave_like "servers"
-
-    def server_type
-      ThreadedServer
+  describe Thrift::ThreadedServer do
+    before(:each) do
+      @processor = mock("Processor")
+      @serverTrans = mock("ServerTransport")
+      @trans = mock("BaseTransport")
+      @prot = mock("BaseProtocol")
+      @client = mock("Client")
+      @server = described_class.new(@processor, @serverTrans, @trans, @prot)
     end
 
     it "should serve using threads" do
@@ -95,50 +89,44 @@ class ThriftServerSpec < Spec::ExampleGroup
     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
-    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)
+  describe Thrift::ThreadPoolServer do
+    before(:each) do
+      @processor = mock("Processor")
+      @server_trans = mock("ServerTransport")
+      @trans = mock("BaseTransport")
+      @prot = mock("BaseProtocol")
+      @client = mock("Client")
+      @server = described_class.new(@processor, @server_trans, @trans, @prot)
     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)
+      described_class.any_instance.should_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'))
     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)
+      described_class.any_instance.should_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_q = mock("SizedQueue")
+      exception_q = mock("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
-      @serverTrans.should_receive(:accept).exactly(3).times.and_return(@client)
+      @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)
       x = 0
@@ -151,9 +139,9 @@ class ThriftServerSpec < Spec::ExampleGroup
         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)
+      exception_q.should_receive(:push).with(error).and_throw(:stop)
+      @server_trans.should_receive(:close)
+      expect { @server.serve }.to(throw_symbol(:stop))
     end
   end
 end