thrift-mavericks 0.8.0 → 0.9.0.1

data/lib/thrift/transport/socket.rb

@@ -34,8 +34,9 @@ module Thrift
 
     def open
       begin
-        addrinfo = ::Socket::getaddrinfo(@host, @port).first
+        addrinfo = ::Socket::getaddrinfo(@host, @port, nil, ::Socket::SOCK_STREAM).first
         @handle = ::Socket.new(addrinfo[4], ::Socket::SOCK_STREAM, 0)
+        @handle.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
         sockaddr = ::Socket.sockaddr_in(addrinfo[1], addrinfo[3])
         begin
           @handle.connect_nonblock(sockaddr)
@@ -60,6 +61,7 @@ module Thrift
 
     def write(str)
       raise IOError, "closed stream" unless open?
+      str = Bytes.force_binary_encoding(str)
       begin
         if @timeout.nil? or @timeout == 0
           @handle.write(str)
@@ -134,4 +136,4 @@ module Thrift
       @handle
     end
   end
-end
+end

data/spec/ThriftSpec.thrift

@@ -129,4 +129,55 @@ struct Struct_with_union {
 
 struct StructWithEnumMap {
   1: map<SomeEnum, list<SomeEnum>> my_map;
-}
+}
+
+# Nested lists
+struct NestedListInList {
+  1: list<list<byte>> value
+}
+
+struct NestedListInSet {
+  1: set<list<byte>> value
+}
+
+struct NestedListInMapKey {
+  1: map<list<byte>, byte> value
+}
+
+struct NestedListInMapValue {
+  1: map<byte, list<byte>> value
+}
+
+# Nested sets
+struct NestedSetInList {
+  1: list<set<byte>> value
+}
+
+struct NestedSetInSet {
+  1: set<set<byte>> value
+}
+
+struct NestedSetInMapKey {
+  1: map<set<byte>, byte> value
+}
+
+struct NestedSetInMapValue {
+  1: map<byte, set<byte>> value
+}
+
+# Nested maps
+struct NestedMapInList {
+  1: list<map<byte, byte>> value
+}
+
+struct NestedMapInSet {
+  1: set<map<byte, byte>> value
+}
+
+struct NestedMapInMapKey {
+  2: map<map<byte, byte>, byte> value
+}
+
+struct NestedMapInMapValue {
+  2: map<byte, map<byte, byte>> value
+}

data/spec/base_protocol_spec.rb

@@ -17,31 +17,61 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
-class ThriftBaseProtocolSpec < Spec::ExampleGroup
-  include Thrift
+describe 'BaseProtocol' do
 
   before(:each) do
     @trans = mock("MockTransport")
-    @prot = BaseProtocol.new(@trans)
+    @prot = Thrift::BaseProtocol.new(@trans)
   end
 
-  describe BaseProtocol do
+  describe Thrift::BaseProtocol do
     # most of the methods are stubs, so we can ignore them
 
     it "should make trans accessible" do
       @prot.trans.should eql(@trans)
     end
 
-    it "should write out a field nicely" do
+    it 'should write out a field nicely (deprecated write_field signature)' do
       @prot.should_receive(:write_field_begin).with('field', 'type', 'fid').ordered
-      @prot.should_receive(:write_type).with('type', 'value').ordered
+      @prot.should_receive(:write_type).with({:name => 'field', :type => 'type'}, 'value').ordered
       @prot.should_receive(:write_field_end).ordered
       @prot.write_field('field', 'type', 'fid', 'value')
     end
 
-    it "should write out the different types" do
+    it 'should write out a field nicely' do
+      @prot.should_receive(:write_field_begin).with('field', 'type', 'fid').ordered
+      @prot.should_receive(:write_type).with({:name => 'field', :type => 'type', :binary => false}, 'value').ordered
+      @prot.should_receive(:write_field_end).ordered
+      @prot.write_field({:name => 'field', :type => 'type', :binary => false}, 'fid', 'value')
+    end
+
+    it 'should write out the different types (deprecated write_type signature)' do
+      @prot.should_receive(:write_bool).with('bool').ordered
+      @prot.should_receive(:write_byte).with('byte').ordered
+      @prot.should_receive(:write_double).with('double').ordered
+      @prot.should_receive(:write_i16).with('i16').ordered
+      @prot.should_receive(:write_i32).with('i32').ordered
+      @prot.should_receive(:write_i64).with('i64').ordered
+      @prot.should_receive(:write_string).with('string').ordered
+      struct = mock('Struct')
+      struct.should_receive(:write).with(@prot).ordered
+      @prot.write_type(Thrift::Types::BOOL, 'bool')
+      @prot.write_type(Thrift::Types::BYTE, 'byte')
+      @prot.write_type(Thrift::Types::DOUBLE, 'double')
+      @prot.write_type(Thrift::Types::I16, 'i16')
+      @prot.write_type(Thrift::Types::I32, 'i32')
+      @prot.write_type(Thrift::Types::I64, 'i64')
+      @prot.write_type(Thrift::Types::STRING, 'string')
+      @prot.write_type(Thrift::Types::STRUCT, struct)
+      # all other types are not implemented
+      [Thrift::Types::STOP, Thrift::Types::VOID, Thrift::Types::MAP, Thrift::Types::SET, Thrift::Types::LIST].each do |type|
+        expect { @prot.write_type(type, type.to_s) }.to raise_error(NotImplementedError)
+      end
+    end
+
+    it 'should write out the different types' do
       @prot.should_receive(:write_bool).with('bool').ordered
       @prot.should_receive(:write_byte).with('byte').ordered
       @prot.should_receive(:write_double).with('double').ordered
@@ -49,23 +79,47 @@ class ThriftBaseProtocolSpec < Spec::ExampleGroup
       @prot.should_receive(:write_i32).with('i32').ordered
       @prot.should_receive(:write_i64).with('i64').ordered
       @prot.should_receive(:write_string).with('string').ordered
+      @prot.should_receive(:write_binary).with('binary').ordered
       struct = mock('Struct')
       struct.should_receive(:write).with(@prot).ordered
-      @prot.write_type(Types::BOOL, 'bool')
-      @prot.write_type(Types::BYTE, 'byte')
-      @prot.write_type(Types::DOUBLE, 'double')
-      @prot.write_type(Types::I16, 'i16')
-      @prot.write_type(Types::I32, 'i32')
-      @prot.write_type(Types::I64, 'i64')
-      @prot.write_type(Types::STRING, 'string')
-      @prot.write_type(Types::STRUCT, struct)
+      @prot.write_type({:type => Thrift::Types::BOOL}, 'bool')
+      @prot.write_type({:type => Thrift::Types::BYTE}, 'byte')
+      @prot.write_type({:type => Thrift::Types::DOUBLE}, 'double')
+      @prot.write_type({:type => Thrift::Types::I16}, 'i16')
+      @prot.write_type({:type => Thrift::Types::I32}, 'i32')
+      @prot.write_type({:type => Thrift::Types::I64}, 'i64')
+      @prot.write_type({:type => Thrift::Types::STRING}, 'string')
+      @prot.write_type({:type => Thrift::Types::STRING, :binary => true}, 'binary')
+      @prot.write_type({:type => Thrift::Types::STRUCT}, struct)
+      # all other types are not implemented
+      [Thrift::Types::STOP, Thrift::Types::VOID, Thrift::Types::MAP, Thrift::Types::SET, Thrift::Types::LIST].each do |type|
+        expect { @prot.write_type({:type => type}, type.to_s) }.to raise_error(NotImplementedError)
+      end
+    end
+
+    it 'should read the different types (deprecated read_type signature)' do
+      @prot.should_receive(:read_bool).ordered
+      @prot.should_receive(:read_byte).ordered
+      @prot.should_receive(:read_i16).ordered
+      @prot.should_receive(:read_i32).ordered
+      @prot.should_receive(:read_i64).ordered
+      @prot.should_receive(:read_double).ordered
+      @prot.should_receive(:read_string).ordered
+      @prot.read_type(Thrift::Types::BOOL)
+      @prot.read_type(Thrift::Types::BYTE)
+      @prot.read_type(Thrift::Types::I16)
+      @prot.read_type(Thrift::Types::I32)
+      @prot.read_type(Thrift::Types::I64)
+      @prot.read_type(Thrift::Types::DOUBLE)
+      @prot.read_type(Thrift::Types::STRING)
       # all other types are not implemented
-      [Types::STOP, Types::VOID, Types::MAP, Types::SET, Types::LIST].each do |type|
-        lambda { @prot.write_type(type, type.to_s) }.should raise_error(NotImplementedError)
+      [Thrift::Types::STOP, Thrift::Types::VOID, Thrift::Types::MAP,
+       Thrift::Types::SET, Thrift::Types::LIST, Thrift::Types::STRUCT].each do |type|
+        expect { @prot.read_type(type) }.to raise_error(NotImplementedError)
       end
     end
 
-    it "should read the different types" do
+    it 'should read the different types' do
       @prot.should_receive(:read_bool).ordered
       @prot.should_receive(:read_byte).ordered
       @prot.should_receive(:read_i16).ordered
@@ -73,16 +127,19 @@ class ThriftBaseProtocolSpec < Spec::ExampleGroup
       @prot.should_receive(:read_i64).ordered
       @prot.should_receive(:read_double).ordered
       @prot.should_receive(:read_string).ordered
-      @prot.read_type(Types::BOOL)
-      @prot.read_type(Types::BYTE)
-      @prot.read_type(Types::I16)
-      @prot.read_type(Types::I32)
-      @prot.read_type(Types::I64)
-      @prot.read_type(Types::DOUBLE)
-      @prot.read_type(Types::STRING)
+      @prot.should_receive(:read_binary).ordered
+      @prot.read_type({:type => Thrift::Types::BOOL})
+      @prot.read_type({:type => Thrift::Types::BYTE})
+      @prot.read_type({:type => Thrift::Types::I16})
+      @prot.read_type({:type => Thrift::Types::I32})
+      @prot.read_type({:type => Thrift::Types::I64})
+      @prot.read_type({:type => Thrift::Types::DOUBLE})
+      @prot.read_type({:type => Thrift::Types::STRING})
+      @prot.read_type({:type => Thrift::Types::STRING, :binary => true})
       # all other types are not implemented
-      [Types::STOP, Types::VOID, Types::MAP, Types::SET, Types::LIST].each do |type|
-        lambda { @prot.read_type(type) }.should raise_error(NotImplementedError)
+      [Thrift::Types::STOP, Thrift::Types::VOID, Thrift::Types::MAP,
+       Thrift::Types::SET, Thrift::Types::LIST, Thrift::Types::STRUCT].each do |type|
+        expect { @prot.read_type({:type => type}) }.to raise_error(NotImplementedError)
       end
     end
 
@@ -94,67 +151,67 @@ class ThriftBaseProtocolSpec < Spec::ExampleGroup
       @prot.should_receive(:read_i64).ordered
       @prot.should_receive(:read_double).ordered
       @prot.should_receive(:read_string).ordered
-      @prot.skip(Types::BOOL)
-      @prot.skip(Types::BYTE)
-      @prot.skip(Types::I16)
-      @prot.skip(Types::I32)
-      @prot.skip(Types::I64)
-      @prot.skip(Types::DOUBLE)
-      @prot.skip(Types::STRING)
-      @prot.skip(Types::STOP) # should do absolutely nothing
+      @prot.skip(Thrift::Types::BOOL)
+      @prot.skip(Thrift::Types::BYTE)
+      @prot.skip(Thrift::Types::I16)
+      @prot.skip(Thrift::Types::I32)
+      @prot.skip(Thrift::Types::I64)
+      @prot.skip(Thrift::Types::DOUBLE)
+      @prot.skip(Thrift::Types::STRING)
+      @prot.skip(Thrift::Types::STOP) # should do absolutely nothing
     end
 
     it "should skip structs" do
       real_skip = @prot.method(:skip)
       @prot.should_receive(:read_struct_begin).ordered
       @prot.should_receive(:read_field_begin).exactly(4).times.and_return(
-        ['field 1', Types::STRING, 1],
-        ['field 2', Types::I32, 2],
-        ['field 3', Types::MAP, 3],
-        [nil, Types::STOP, 0]
+        ['field 1', Thrift::Types::STRING, 1],
+        ['field 2', Thrift::Types::I32, 2],
+        ['field 3', Thrift::Types::MAP, 3],
+        [nil, Thrift::Types::STOP, 0]
       )
       @prot.should_receive(:read_field_end).exactly(3).times
       @prot.should_receive(:read_string).exactly(3).times
       @prot.should_receive(:read_i32).ordered
-      @prot.should_receive(:read_map_begin).ordered.and_return([Types::STRING, Types::STRING, 1])
+      @prot.should_receive(:read_map_begin).ordered.and_return([Thrift::Types::STRING, Thrift::Types::STRING, 1])
       # @prot.should_receive(:read_string).exactly(2).times
       @prot.should_receive(:read_map_end).ordered
       @prot.should_receive(:read_struct_end).ordered
-      real_skip.call(Types::STRUCT)
+      real_skip.call(Thrift::Types::STRUCT)
     end
 
     it "should skip maps" do
       real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_map_begin).ordered.and_return([Types::STRING, Types::STRUCT, 1])
+      @prot.should_receive(:read_map_begin).ordered.and_return([Thrift::Types::STRING, Thrift::Types::STRUCT, 1])
       @prot.should_receive(:read_string).ordered
       @prot.should_receive(:read_struct_begin).ordered.and_return(["some_struct"])
-      @prot.should_receive(:read_field_begin).ordered.and_return([nil, Types::STOP, nil]);
+      @prot.should_receive(:read_field_begin).ordered.and_return([nil, Thrift::Types::STOP, nil]);
       @prot.should_receive(:read_struct_end).ordered
       @prot.should_receive(:read_map_end).ordered
-      real_skip.call(Types::MAP)
+      real_skip.call(Thrift::Types::MAP)
     end
 
     it "should skip sets" do
       real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_set_begin).ordered.and_return([Types::I64, 9])
+      @prot.should_receive(:read_set_begin).ordered.and_return([Thrift::Types::I64, 9])
       @prot.should_receive(:read_i64).ordered.exactly(9).times
       @prot.should_receive(:read_set_end)
-      real_skip.call(Types::SET)
+      real_skip.call(Thrift::Types::SET)
     end
 
     it "should skip lists" do
       real_skip = @prot.method(:skip)
-      @prot.should_receive(:read_list_begin).ordered.and_return([Types::DOUBLE, 11])
+      @prot.should_receive(:read_list_begin).ordered.and_return([Thrift::Types::DOUBLE, 11])
       @prot.should_receive(:read_double).ordered.exactly(11).times
       @prot.should_receive(:read_list_end)
-      real_skip.call(Types::LIST)
+      real_skip.call(Thrift::Types::LIST)
     end
   end
 
-  describe BaseProtocolFactory do
+  describe Thrift::BaseProtocolFactory do
     it "should raise NotImplementedError" do
       # returning nil since Protocol is just an abstract class
-      lambda {BaseProtocolFactory.new.get_protocol(mock("MockTransport"))}.should raise_error(NotImplementedError)
+      lambda {Thrift::BaseProtocolFactory.new.get_protocol(mock("MockTransport"))}.should raise_error(NotImplementedError)
     end
   end
 end

data/spec/base_transport_spec.rb

@@ -17,22 +17,21 @@
 # under the License.
 #
 
-require File.expand_path("#{File.dirname(__FILE__)}/spec_helper")
+require 'spec_helper'
 
-class ThriftBaseTransportSpec < Spec::ExampleGroup
-  include Thrift
+describe 'BaseTransport' do
 
-  describe TransportException do
+  describe Thrift::TransportException do
     it "should make type accessible" do
-      exc = TransportException.new(TransportException::ALREADY_OPEN, "msg")
-      exc.type.should == TransportException::ALREADY_OPEN
+      exc = Thrift::TransportException.new(Thrift::TransportException::ALREADY_OPEN, "msg")
+      exc.type.should == Thrift::TransportException::ALREADY_OPEN
       exc.message.should == "msg"
     end
   end
 
-  describe BaseTransport do
+  describe Thrift::BaseTransport do
     it "should read the specified size" do
-      transport = BaseTransport.new
+      transport = Thrift::BaseTransport.new
       transport.should_receive(:read).with(40).ordered.and_return("10 letters")
       transport.should_receive(:read).with(30).ordered.and_return("fifteen letters")
       transport.should_receive(:read).with(15).ordered.and_return("more characters")
@@ -42,47 +41,47 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
     it "should stub out the rest of the methods" do
       # can't test for stubbiness, so just make sure they're defined
       [:open?, :open, :close, :read, :write, :flush].each do |sym|
-        BaseTransport.method_defined?(sym).should be_true
+        Thrift::BaseTransport.method_defined?(sym).should be_true
       end
     end
 
     it "should alias << to write" do
-      BaseTransport.instance_method(:<<).should == BaseTransport.instance_method(:write)
+      Thrift::BaseTransport.instance_method(:<<).should == Thrift::BaseTransport.instance_method(:write)
     end
   end
 
-  describe BaseServerTransport do
+  describe Thrift::BaseServerTransport do
     it "should stub out its methods" do
       [:listen, :accept, :close].each do |sym|
-        BaseServerTransport.method_defined?(sym).should be_true
+        Thrift::BaseServerTransport.method_defined?(sym).should be_true
       end
     end
   end
 
-  describe BaseTransportFactory do
+  describe Thrift::BaseTransportFactory do
     it "should return the transport it's given" do
       transport = mock("Transport")
-      BaseTransportFactory.new.get_transport(transport).should eql(transport)
+      Thrift::BaseTransportFactory.new.get_transport(transport).should eql(transport)
     end
   end
 
-  describe BufferedTransport do
+  describe Thrift::BufferedTransport do
     it "should pass through everything but write/flush/read" do
       trans = mock("Transport")
       trans.should_receive(:open?).ordered.and_return("+ open?")
       trans.should_receive(:open).ordered.and_return("+ open")
       trans.should_receive(:flush).ordered # from the close
       trans.should_receive(:close).ordered.and_return("+ close")
-      btrans = BufferedTransport.new(trans)
+      btrans = Thrift::BufferedTransport.new(trans)
       btrans.open?.should == "+ open?"
       btrans.open.should == "+ open"
       btrans.close.should == "+ close"
     end
-    
-    it "should buffer reads in chunks of #{BufferedTransport::DEFAULT_BUFFER}" do
+
+    it "should buffer reads in chunks of #{Thrift::BufferedTransport::DEFAULT_BUFFER}" do
       trans = mock("Transport")
-      trans.should_receive(:read).with(BufferedTransport::DEFAULT_BUFFER).and_return("lorum ipsum dolor emet")
-      btrans = BufferedTransport.new(trans)
+      trans.should_receive(:read).with(Thrift::BufferedTransport::DEFAULT_BUFFER).and_return("lorum ipsum dolor emet")
+      btrans = Thrift::BufferedTransport.new(trans)
       btrans.read(6).should == "lorum "
       btrans.read(6).should == "ipsum "
       btrans.read(6).should == "dolor "
@@ -91,7 +90,7 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
 
     it "should buffer writes and send them on flush" do
       trans = mock("Transport")
-      btrans = BufferedTransport.new(trans)
+      btrans = Thrift::BufferedTransport.new(trans)
       btrans.write("one/")
       btrans.write("two/")
       btrans.write("three/")
@@ -102,7 +101,7 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
 
     it "should only send buffered data once" do
       trans = mock("Transport")
-      btrans = BufferedTransport.new(trans)
+      btrans = Thrift::BufferedTransport.new(trans)
       btrans.write("one/")
       btrans.write("two/")
       btrans.write("three/")
@@ -112,39 +111,39 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
       # Nothing to flush with no data
       btrans.flush
     end
-    
+
     it "should flush on close" do
       trans = mock("Transport")
       trans.should_receive(:close)
-      btrans = BufferedTransport.new(trans)
+      btrans = Thrift::BufferedTransport.new(trans)
       btrans.should_receive(:flush)
       btrans.close
     end
-    
+
     it "should not write to socket if there's no data" do
       trans = mock("Transport")
       trans.should_receive(:flush)
-      btrans = BufferedTransport.new(trans)
+      btrans = Thrift::BufferedTransport.new(trans)
       btrans.flush
     end
   end
 
-  describe BufferedTransportFactory do
+  describe Thrift::BufferedTransportFactory do
     it "should wrap the given transport in a BufferedTransport" do
       trans = mock("Transport")
       btrans = mock("BufferedTransport")
-      BufferedTransport.should_receive(:new).with(trans).and_return(btrans)
-      BufferedTransportFactory.new.get_transport(trans).should == btrans
+      Thrift::BufferedTransport.should_receive(:new).with(trans).and_return(btrans)
+      Thrift::BufferedTransportFactory.new.get_transport(trans).should == btrans
     end
   end
 
-  describe FramedTransport do
+  describe Thrift::FramedTransport do
     before(:each) do
       @trans = mock("Transport")
     end
 
     it "should pass through open?/open/close" do
-      ftrans = FramedTransport.new(@trans)
+      ftrans = Thrift::FramedTransport.new(@trans)
       @trans.should_receive(:open?).ordered.and_return("+ open?")
       @trans.should_receive(:open).ordered.and_return("+ open")
       @trans.should_receive(:close).ordered.and_return("+ close")
@@ -154,13 +153,13 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
     end
 
     it "should pass through read when read is turned off" do
-      ftrans = FramedTransport.new(@trans, false, true)
+      ftrans = Thrift::FramedTransport.new(@trans, false, true)
       @trans.should_receive(:read).with(17).ordered.and_return("+ read")
       ftrans.read(17).should == "+ read"
     end
 
     it "should pass through write/flush when write is turned off" do
-      ftrans = FramedTransport.new(@trans, true, false)
+      ftrans = Thrift::FramedTransport.new(@trans, true, false)
       @trans.should_receive(:write).with("foo").ordered.and_return("+ write")
       @trans.should_receive(:flush).ordered.and_return("+ flush")
       ftrans.write("foo").should == "+ write"
@@ -171,21 +170,21 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
       frame = "this is a frame"
       @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017")
       @trans.should_receive(:read_all).with(frame.length).and_return(frame)
-      FramedTransport.new(@trans).read(frame.length + 10).should == frame
+      Thrift::FramedTransport.new(@trans).read(frame.length + 10).should == frame
     end
 
     it "should return slices of the frame when asked for < the frame's length" do
       frame = "this is a frame"
       @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017")
       @trans.should_receive(:read_all).with(frame.length).and_return(frame)
-      ftrans = FramedTransport.new(@trans)
+      ftrans = Thrift::FramedTransport.new(@trans)
       ftrans.read(4).should == "this"
       ftrans.read(4).should == " is "
       ftrans.read(16).should == "a frame"
     end
 
     it "should return nothing if asked for <= 0" do
-      FramedTransport.new(@trans).read(-2).should == ""
+      Thrift::FramedTransport.new(@trans).read(-2).should == ""
     end
 
     it "should pull a new frame when the first is exhausted" do
@@ -194,7 +193,7 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
       @trans.should_receive(:read_all).with(4).and_return("\000\000\000\017", "\000\000\000\021")
       @trans.should_receive(:read_all).with(frame.length).and_return(frame)
       @trans.should_receive(:read_all).with(frame2.length).and_return(frame2)
-      ftrans = FramedTransport.new(@trans)
+      ftrans = Thrift::FramedTransport.new(@trans)
       ftrans.read(4).should == "this"
       ftrans.read(8).should == " is a fr"
       ftrans.read(6).should == "ame"
@@ -203,7 +202,7 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
     end
 
     it "should buffer writes" do
-      ftrans = FramedTransport.new(@trans)
+      ftrans = Thrift::FramedTransport.new(@trans)
       @trans.should_not_receive(:write)
       ftrans.write("foo")
       ftrans.write("bar")
@@ -211,7 +210,7 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
     end
 
     it "should write slices of the buffer" do
-      ftrans = FramedTransport.new(@trans)
+      ftrans = Thrift::FramedTransport.new(@trans)
       ftrans.write("foobar", 3)
       ftrans.write("barfoo", 1)
       @trans.stub!(:flush)
@@ -220,7 +219,7 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
     end
 
     it "should flush frames with a 4-byte header" do
-      ftrans = FramedTransport.new(@trans)
+      ftrans = Thrift::FramedTransport.new(@trans)
       @trans.should_receive(:write).with("\000\000\000\035one/two/three/this is a frame").ordered
       @trans.should_receive(:flush).ordered
       ftrans.write("one/")
@@ -231,7 +230,7 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
     end
 
     it "should not flush the same buffered data twice" do
-      ftrans = FramedTransport.new(@trans)
+      ftrans = Thrift::FramedTransport.new(@trans)
       @trans.should_receive(:write).with("\000\000\000\007foo/bar")
       @trans.stub!(:flush)
       ftrans.write("foo")
@@ -242,22 +241,22 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
     end
   end
 
-  describe FramedTransportFactory do
+  describe Thrift::FramedTransportFactory do
     it "should wrap the given transport in a FramedTransport" do
       trans = mock("Transport")
-      FramedTransport.should_receive(:new).with(trans)
-      FramedTransportFactory.new.get_transport(trans)
+      Thrift::FramedTransport.should_receive(:new).with(trans)
+      Thrift::FramedTransportFactory.new.get_transport(trans)
     end
   end
 
-  describe MemoryBufferTransport do
+  describe Thrift::MemoryBufferTransport do
     before(:each) do
-      @buffer = MemoryBufferTransport.new
+      @buffer = Thrift::MemoryBufferTransport.new
     end
 
     it "should accept a buffer on input and use it directly" do
       s = "this is a test"
-      @buffer = MemoryBufferTransport.new(s)
+      @buffer = Thrift::MemoryBufferTransport.new(s)
       @buffer.read(4).should == "this"
       s.slice!(-4..-1)
       @buffer.read(@buffer.available).should == " is a "
@@ -307,7 +306,7 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
       @buffer.write " bar"
       @buffer.read(@buffer.available).should == "foo bar"
     end
-    
+
     it "should throw an EOFError when there isn't enough data in the buffer" do
       @buffer.reset_buffer("")
       lambda{@buffer.read(1)}.should raise_error(EOFError)
@@ -317,11 +316,11 @@ class ThriftBaseTransportSpec < Spec::ExampleGroup
     end
   end
 
-  describe IOStreamTransport do
+  describe Thrift::IOStreamTransport do
     before(:each) do
       @input = mock("Input", :closed? => false)
       @output = mock("Output", :closed? => false)
-      @trans = IOStreamTransport.new(@input, @output)
+      @trans = Thrift::IOStreamTransport.new(@input, @output)
     end
 
     it "should be open as long as both input or output are open" do