thrift 0.8.0 → 0.13.0

data/spec/namespaced_spec.rb

@@ -0,0 +1,67 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+require 'spec_helper'
+
+describe 'namespaced generation' do
+  before do
+    require 'namespaced_spec_namespace/namespaced_nonblocking_service'
+  end
+
+  it "generated the right files" do
+    prefix = File.expand_path("../gen-rb", __FILE__)
+    ["namespaced_spec_namespace/namespaced_nonblocking_service.rb",
+     "namespaced_spec_namespace/thrift_namespaced_spec_constants.rb",
+     "namespaced_spec_namespace/thrift_namespaced_spec_types.rb",
+     "other_namespace/referenced_constants.rb",
+     "other_namespace/referenced_types.rb"
+    ].each do |name|
+      expect(File.exist?(File.join(prefix, name))).to be_truthy
+    end
+  end
+
+  it "did not generate the wrong files" do
+    prefix = File.expand_path("../gen-rb", __FILE__)
+    ["namespaced_nonblocking_service.rb",
+     "thrift_namespaced_spec_constants.rb",
+     "thrift_namespaced_spec_types.rb",
+     "referenced_constants.rb",
+     "referenced_types.rb"
+    ].each do |name|
+      expect(File.exist?(File.join(prefix, name))).not_to be_truthy
+    end
+  end
+
+  it "has a service class in the right place" do
+    expect(defined?(NamespacedSpecNamespace::NamespacedNonblockingService)).to be_truthy
+  end
+
+  it "has a struct in the right place" do
+    expect(defined?(NamespacedSpecNamespace::Hello)).to be_truthy
+  end
+
+  it "required an included file" do
+    expect(defined?(OtherNamespace::SomeEnum)).to be_truthy
+  end
+
+  it "extended a service" do
+    require "extended/extended_service"
+  end
+
+end

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!')
+      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
+      expect(client.greeting(false)).to eq(SpecNamespace::Hello.new(:greeting => 'Aloha!'))
       @server.shutdown
     end
 
@@ -197,7 +195,7 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
       end
       4.times { trans_queue.pop }
       setup_client.unblock(4)
-      4.times { queue.pop.should be_true }
+      4.times { expect(queue.pop).to be_truthy }
       @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 { expect(result.pop).to eq(SpecNamespace::Hello.new) }
+      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
       queues[5] << [:unblock, 4]
-      4.times { result.pop.should be_true }
+      4.times { expect(result.pop).to be_truthy }
       queues[2] << :hello
-      result.pop.should == Hello.new
-      client.greeting(false).should == Hello.new(:greeting => 'Aloha!')
+      expect(result.pop).to eq(SpecNamespace::Hello.new)
+      expect(client.greeting(false)).to eq(SpecNamespace::Hello.new(:greeting => 'Aloha!'))
       7.times { queues.shift << :exit }
-      client.greeting(true).should == Hello.new
+      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
       @server.shutdown
     end
 
@@ -231,7 +229,7 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
       client = setup_client
       client.greeting(false) # force a message pass
       @server.shutdown
-      @server_thread.join(2).should be_an_instance_of(Thread)
+      expect(@server_thread.join(2)).to be_an_instance_of(Thread)
     end
 
     it "should continue processing active messages when shutting down" do
@@ -240,8 +238,8 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
       client << :sleep
       sleep 0.1 # give the server time to start processing the client's message
       @server.shutdown
-      @server_thread.join(2).should be_an_instance_of(Thread)
-      result.pop.should == :slept
+      expect(@server_thread.join(2)).to be_an_instance_of(Thread)
+      expect(result.pop).to eq(:slept)
     end
 
     it "should kill active messages when they don't expire while shutting down" do
@@ -251,15 +249,15 @@ class ThriftNonblockingServerSpec < Spec::ExampleGroup
       sleep 0.1 # start processing the client's message
       @server.shutdown(1)
       @catch_exceptions = true
-      @server_thread.join(3).should_not be_nil
-      result.should be_empty
+      expect(@server_thread.join(3)).not_to be_nil
+      expect(result).to be_empty
     end
 
     it "should allow shutting down in response to a message" do
       client = setup_client
-      client.greeting(true).should == Hello.new
+      expect(client.greeting(true)).to eq(SpecNamespace::Hello.new)
       client.shutdown
-      @server_thread.join(2).should_not be_nil
+      expect(@server_thread.join(2)).not_to be_nil
     end
   end
 end

data/spec/processor_spec.rb

@@ -17,65 +17,62 @@
 # 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")
+      @processor = ProcessorSpec.new(double("MockHandler"))
+      @prot = double("MockProtocol")
     end
 
     def mock_trans(obj)
-      obj.should_receive(:trans).ordered.and_return do
-        mock("trans").tee 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', MessageTypes::CALL, 17]
-      @processor.should_receive(:process_testMessage).with(17, @prot, @prot).ordered
-      @processor.process(@prot, @prot).should == true
+      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
 
     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_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_end).ordered
+      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 = double(Thrift::ApplicationException)
+      expect(e).to receive(:write).with(@prot).ordered
+      expect(Thrift::ApplicationException).to receive(:new).with(Thrift::ApplicationException::UNKNOWN_METHOD, "Unknown function testMessage").and_return(e)
+      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>").tee do |args|
-        args.should_receive(:read).with(@prot).ordered
+      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', MessageTypes::REPLY, 23).ordered
-      result = mock("MockResult")
-      result.should_receive(:write).with(@prot).ordered
-      @prot.should_receive(:write_message_end).ordered
+      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/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!"))
-      data.should == "\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00"
+      serializer = Thrift::Serializer.new(Thrift::BinaryProtocolAcceleratedFactory.new)
+      data = serializer.serialize(SpecNamespace::Hello.new(:greeting => "'Ello guv'nor!"))
+      expect(data).to eq("\x0B\x00\x01\x00\x00\x00\x0E'Ello guv'nor!\x00")
     end
 
     it "should serialize structs to the given protocol" do
-      protocol = 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_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"))
+      protocol = Thrift::BaseProtocol.new(double("transport"))
+      expect(protocol).to receive(:write_struct_begin).with("SpecNamespace::Hello")
+      expect(protocol).to receive(:write_field_begin).with("greeting", Thrift::Types::STRING, 1)
+      expect(protocol).to receive(:write_string).with("Good day")
+      expect(protocol).to receive(:write_field_end)
+      expect(protocol).to receive(:write_field_stop)
+      expect(protocol).to receive(:write_struct_end)
+      protocol_factory = double("ProtocolFactory")
+      allow(protocol_factory).to receive(:get_protocol).and_return(protocol)
+      serializer = Thrift::Serializer.new(protocol_factory)
+      serializer.serialize(SpecNamespace::Hello.new(:greeting => "Good day"))
     end
   end
 
-  describe 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!")
+      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 = 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_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")
+      protocol = Thrift::BaseProtocol.new(double("transport"))
+      expect(protocol).to receive(:read_struct_begin).and_return("SpecNamespace::Hello")
+      expect(protocol).to receive(:read_field_begin).and_return(["greeting", Thrift::Types::STRING, 1],
+                                                            [nil, Thrift::Types::STOP, 0])
+      expect(protocol).to receive(:read_string).and_return("Good day")
+      expect(protocol).to receive(:read_field_end)
+      expect(protocol).to receive(:read_struct_end)
+      protocol_factory = double("ProtocolFactory")
+      allow(protocol_factory).to receive(:get_protocol).and_return(protocol)
+      deserializer = Thrift::Deserializer.new(protocol_factory)
+      expect(deserializer.deserialize(SpecNamespace::Hello.new, "")).to eq(SpecNamespace::Hello.new(:greeting => "Good day"))
     end
   end
 end

data/spec/server_socket_spec.rb

@@ -17,64 +17,68 @@
 # 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
-      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 = ServerSocket.new('localhost', 1234)
-      TCPServer.should_receive(:new).with('localhost', 1234)
+      @socket = Thrift::ServerSocket.new('localhost', 1234)
+      expect(TCPServer).to receive(:new).with('localhost', 1234)
+      @socket.to_s == "server(localhost:1234)"
       @socket.listen
     end
 
     it "should create a Thrift::Socket to wrap accepted sockets" do
-      handle = 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")
-     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