thrift 0.0.751142

data/spec/ThriftSpec.thrift

@@ -0,0 +1,46 @@
+namespace rb SpecNamespace
+
+struct Hello {
+  1: string greeting = "hello world"
+}
+
+struct Foo {
+  1: i32 simple = 53,
+  2: string words = "words",
+  3: Hello hello = {'greeting' : "hello, world!"},
+  4: list<i32> ints = [1, 2, 2, 3],
+  5: map<i32, map<string, double>> complex,
+  6: set<i16> shorts = [5, 17, 239],
+  7: optional string opt_string
+}
+
+struct BoolStruct {
+  1: bool yesno = 1
+}
+
+struct SimpleList {
+  1: list<bool> bools,
+  2: list<byte> bytes,
+  3: list<i16> i16s,
+  4: list<i32> i32s,
+  5: list<i64> i64s,
+  6: list<double> doubles,
+  7: list<string> strings,
+  8: list<map<i16, i16>> maps,
+  9: list<list<i16>> lists,
+  10: list<set<i16>> sets,
+  11: list<Hello> hellos
+}
+
+exception Xception {
+  1: string message,
+  2: i32 code = 1
+}
+
+service NonblockingService {
+  Hello greeting(1:bool english)
+  bool block()
+  async void unblock(1:i32 n)
+  async void shutdown()
+  void sleep(1:double seconds)
+}

data/spec/backwards_compatibility_spec.rb

@@ -0,0 +1,136 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'thrift/protocol/binaryprotocol'
+require 'thrift/server/httpserver'
+require 'thrift/transport/httpclient'
+
+context "Backwards compatibility" do
+  specify "old class names should map to new classes" do
+    Thrift::DeprecationProxy.reset_deprecation_warnings
+    # use an Array because a Hash will call #hash and trigger deprecation warnings
+    klasses = [
+      [:module, :ThriftClient,               Thrift::Client],
+      [:class,  :TException,                 Thrift::Exception],
+      [:class,  :TApplicationException,      Thrift::ApplicationException],
+      [:module, :TProcessor,                 Thrift::Processor],
+      [:class,  :TProtocolException,         Thrift::ProtocolException],
+      [:class,  :TProtocol,                  Thrift::Protocol],
+      [:class,  :TProtocolFactory,           Thrift::ProtocolFactory],
+      [:class,  :TBinaryProtocol,            Thrift::BinaryProtocol],
+      [:class,  :TBinaryProtocolFactory,     Thrift::BinaryProtocolFactory],
+      [:class,  :TSimpleMongrelHTTPServer,   Thrift::SimpleMongrelHTTPServer],
+      [:class,  :TServer,                    Thrift::Server],
+      [:class,  :TSimpleServer,              Thrift::SimpleServer],
+      [:class,  :TThreadedServer,            Thrift::ThreadedServer],
+      [:class,  :TThreadPoolServer,          Thrift::ThreadPoolServer],
+      [:module, :ThriftStruct,               Thrift::Struct],
+      [:class,  :THttpClient,                Thrift::HTTPClient],
+      [:class,  :TSocket,                    Thrift::Socket],
+      [:class,  :TServerSocket,              Thrift::ServerSocket],
+      [:class,  :TTransportException,        Thrift::TransportException],
+      [:class,  :TTransport,                 Thrift::Transport],
+      [:class,  :TServerTransport,           Thrift::ServerTransport],
+      [:class,  :TTransportFactory,          Thrift::TransportFactory],
+      [:class,  :TBufferedTransport,         Thrift::BufferedTransport],
+      [:class,  :TBufferedTransportFactory,  Thrift::BufferedTransportFactory],
+      [:class,  :TFramedTransport,           Thrift::FramedTransport],
+      [:class,  :TFramedTransportFactory,    Thrift::FramedTransportFactory],
+      [:class,  :TMemoryBuffer,              Thrift::MemoryBuffer],
+      [:class,  :TIOStreamTransport,         Thrift::IOStreamTransport],
+      [:module, :TType,                      Thrift::Types],
+      [:module, :TMessageType,               Thrift::MessageTypes]
+    ]
+    klasses.each do |(type, oldname, newklass)|
+      oldklass = Object.const_get(oldname)
+      STDERR.should_receive(:puts).with("Warning: #{type} #{oldname} is deprecated").ordered
+      STDERR.should_receive(:puts).with("  from #{__FILE__}:#{__LINE__+1}").ordered
+      oldklass.should eql(newklass)
+      STDERR.rspec_verify
+      STDERR.rspec_reset
+    end
+  end
+
+  specify "old method names should map to new method names" do
+    mapping = {
+      Thrift::Protocol => {
+        :writeMessageBegin => :write_message_begin,
+        :writeMessageEnd => :write_message_end,
+        :writeStructBegin => :write_struct_begin,
+        :writeStructEnd => :write_struct_end,
+        :writeFieldBegin => :write_field_begin,
+        :writeFieldEnd => :write_field_end,
+        :writeFieldStop => :write_field_stop,
+        :writeMapBegin => :write_map_begin,
+        :writeMapEnd => :write_map_end,
+        :writeListBegin => :write_list_begin,
+        :writeListEnd => :write_list_end,
+        :writeSetBegin => :write_set_begin,
+        :writeSetEnd => :write_set_end,
+        :writeBool => :write_bool,
+        :writeByte => :write_byte,
+        :writeI16 => :write_i16,
+        :writeI32 => :write_i32,
+        :writeI64 => :write_i64,
+        :writeDouble => :write_double,
+        :writeString => :write_string,
+        :readMessageBegin => :read_message_begin,
+        :readMessageEnd => :read_message_end,
+        :readStructBegin => :read_struct_begin,
+        :readStructEnd => :read_struct_end,
+        :readFieldBegin => :read_field_begin,
+        :readFieldEnd => :read_field_end,
+        :readMapBegin => :read_map_begin,
+        :readMapEnd => :read_map_end,
+        :readListBegin => :read_list_begin,
+        :readListEnd => :read_list_end,
+        :readSetBegin => :read_set_begin,
+        :readSetEnd => :read_set_end,
+        :readBool => :read_bool,
+        :readByte => :read_byte,
+        :readI16 => :read_i16,
+        :readI32 => :read_i32,
+        :readI64 => :read_i64,
+        :readDouble => :read_double,
+        :readString => :read_string
+      },
+      Thrift::ProtocolFactory => {
+        :getProtocol => :get_protocol
+      },
+      Thrift::Transport => {
+        :isOpen => :open?,
+        :is_open? => :open?,
+        :readAll => :read_all
+      },
+      Thrift::TransportFactory => {
+        :getTransport => :get_transport
+      }
+    }
+    STDERR.stub!(:puts) # stub the deprecation warnings
+    mapping.each_pair do |klass, methods|
+      # save these so they can be used after being mocked up
+      defn_method = klass.method(:define_method)
+      inst_method = klass.method(:instance_method)
+      methods.each_pair do |oldmeth, newmeth|
+        # ensure that calling the old method will call the new method
+        # and then redefine the old method to be the new one
+        klass.should be_method_defined(oldmeth)
+        klass.should be_method_defined(newmeth)
+        orig_method = inst_method.call(:initialize)
+        defn_method.call(:initialize, proc {} ) # stub out initialize
+        begin
+          mockmeth = mock("UnboundMethod: #{newmeth}")
+          mockmeth.should_receive(:bind).and_return do
+            mock("Method: #{newmeth}").tee do |meth|
+              meth.should_receive(:call)
+            end
+          end
+          klass.should_receive(:instance_method).with(newmeth).twice.and_return(mockmeth)
+          klass.should_receive(:define_method).with(oldmeth, mockmeth)
+          klass.new.send oldmeth
+          klass.rspec_verify
+        ensure
+          defn_method.call(:initialize, orig_method)
+        end
+      end
+    end
+  end
+end

data/spec/binaryprotocol_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'thrift/protocol/binaryprotocol'
+require File.dirname(__FILE__) + '/binaryprotocol_spec_shared'
+
+class ThriftBinaryProtocolSpec < Spec::ExampleGroup
+  include Thrift
+
+  describe BinaryProtocol do
+    it_should_behave_like 'a binary protocol'
+
+    def protocol_class
+      BinaryProtocol
+    end
+
+    it "should read a message header" do
+      @trans.should_receive(:read_all).exactly(2).times.and_return(
+        [protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::REPLY].pack('N'),
+        [42].pack('N')
+      )      
+      @prot.should_receive(:read_string).and_return('testMessage')
+      @prot.read_message_begin.should == ['testMessage', Thrift::MessageTypes::REPLY, 42]
+    end
+
+    it "should raise an exception if the message header has the wrong version" do
+      @prot.should_receive(:read_i32).and_return(-1)
+      lambda { @prot.read_message_begin }.should raise_error(Thrift::ProtocolException, 'Missing version identifier') do |e|
+        e.type == Thrift::ProtocolException::BAD_VERSION
+      end
+    end
+
+    it "should raise an exception if the message header does not exist and strict_read is enabled" do
+      @prot.should_receive(:read_i32).and_return(42)
+      @prot.should_receive(:strict_read).and_return(true)
+      lambda { @prot.read_message_begin }.should raise_error(Thrift::ProtocolException, 'No version identifier, old protocol client?') do |e|        
+        e.type == Thrift::ProtocolException::BAD_VERSION
+      end
+    end
+  end
+
+  describe BinaryProtocolFactory do
+    it "should create a BinaryProtocol" do
+      BinaryProtocolFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(BinaryProtocol)
+    end
+  end
+end

data/spec/binaryprotocol_spec_shared.rb

@@ -0,0 +1,274 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+shared_examples_for 'a binary protocol' do
+  before(:each) do
+    @trans = Thrift::MemoryBuffer.new
+    @prot = protocol_class.new(@trans)
+  end
+
+  it "should define the proper VERSION_1, VERSION_MASK AND TYPE_MASK" do
+    protocol_class.const_get(:VERSION_MASK).should == 0xffff0000
+    protocol_class.const_get(:VERSION_1).should == 0x80010000
+    protocol_class.const_get(:TYPE_MASK).should == 0x000000ff
+  end
+
+  it "should make strict_read readable" do
+    @prot.strict_read.should eql(true)
+  end
+
+  it "should make strict_write readable" do
+    @prot.strict_write.should eql(true)
+  end    
+
+  it "should write the message header" do
+    @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
+    @trans.read(1000).should == [protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::CALL, "testMessage".size, "testMessage", 17].pack("NNa11N")
+  end
+  
+  it "should write the message header without version when writes are not strict" do
+    @prot = protocol_class.new(@trans, true, false) # no strict write
+    @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
+    @trans.read(1000).should == "\000\000\000\vtestMessage\001\000\000\000\021"
+  end
+  
+  it "should write the message header with a version when writes are strict" do
+    @prot = protocol_class.new(@trans) # strict write
+    @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
+    @trans.read(1000).should == "\200\001\000\001\000\000\000\vtestMessage\000\000\000\021"
+  end
+  
+
+  # message footer is a noop
+
+  it "should write the field header" do
+    @prot.write_field_begin('foo', Thrift::Types::DOUBLE, 3)
+    @trans.read(1000).should == [Thrift::Types::DOUBLE, 3].pack("cn")
+  end
+  
+  # field footer is a noop
+  
+  it "should write the STOP field" do
+    @prot.write_field_stop
+    @trans.read(1).should == "\000"
+  end
+  
+  it "should write the map header" do
+    @prot.write_map_begin(Thrift::Types::STRING, Thrift::Types::LIST, 17)
+    @trans.read(1000).should == [Thrift::Types::STRING, Thrift::Types::LIST, 17].pack("ccN");
+  end
+   
+  # map footer is a noop
+  
+  it "should write the list header" do
+    @prot.write_list_begin(Thrift::Types::I16, 42)
+    @trans.read(1000).should == [Thrift::Types::I16, 42].pack("cN")
+  end
+  
+  # list footer is a noop
+  
+  it "should write the set header" do
+    @prot.write_set_begin(Thrift::Types::I16, 42)
+    @trans.read(1000).should == [Thrift::Types::I16, 42].pack("cN")
+  end
+  
+  it "should write a bool" do
+    @prot.write_bool(true)
+    @prot.write_bool(false)
+    @trans.read(1000).should == "\001\000"
+  end
+  
+  it "should treat a nil bool as false" do
+    @prot.write_bool(nil)
+    @trans.read(1).should == "\000"
+  end
+  
+  it "should write a byte" do
+    # byte is small enough, let's check -128..127
+    (-128..127).each do |i|
+      @prot.write_byte(i)
+      @trans.read(1).should == [i].pack('c')
+    end
+    (-128..127).each do |i|
+    end
+    # handing it numbers out of signed range should clip
+    @trans.rspec_verify
+    (128..255).each do |i|
+      @prot.write_byte(i)
+      @trans.read(1).should == [i].pack('c')
+    end
+    # and lastly, a Bignum is going to error out
+    lambda { @prot.write_byte(2**65) }.should raise_error(RangeError)
+  end
+  
+  it "should error gracefully when trying to write a nil byte" do
+    lambda { @prot.write_byte(nil) }.should raise_error
+  end
+  
+  it "should write an i16" do
+    # try a random scattering of values
+    # include the signed i16 minimum/maximum
+    [-2**15, -1024, 17, 0, -10000, 1723, 2**15-1].each do |i|
+      @prot.write_i16(i)
+    end
+    # and try something out of signed range, it should clip
+    @prot.write_i16(2**15 + 5)
+    
+    @trans.read(1000).should == "\200\000\374\000\000\021\000\000\330\360\006\273\177\377\200\005"
+    
+    # a Bignum should error
+    # lambda { @prot.write_i16(2**65) }.should raise_error(RangeError)
+  end
+  
+  it "should error gracefully when trying to write a nil i16" do
+    lambda { @prot.write_i16(nil) }.should raise_error
+  end
+  
+  it "should write an i32" do
+    # try a random scattering of values
+    # include the signed i32 minimum/maximum
+    [-2**31, -123123, -2532, -3, 0, 2351235, 12331, 2**31-1].each do |i|
+      @prot.write_i32(i)
+    end
+    # try something out of signed range, it should clip
+    @trans.read(1000).should == "\200\000\000\000" + "\377\376\037\r" + "\377\377\366\034" + "\377\377\377\375" + "\000\000\000\000" + "\000#\340\203" + "\000\0000+" + "\177\377\377\377"
+    [2 ** 31 + 5, 2 ** 65 + 5].each do |i|
+      lambda { @prot.write_i32(i) }.should raise_error(RangeError)  
+    end
+  end
+  
+  it "should error gracefully when trying to write a nil i32" do
+    lambda { @prot.write_i32(nil) }.should raise_error
+  end
+  
+  it "should write an i64" do
+    # try a random scattering of values
+    # try the signed i64 minimum/maximum
+    [-2**63, -12356123612323, -23512351, -234, 0, 1231, 2351236, 12361236213, 2**63-1].each do |i|
+      @prot.write_i64(i)
+    end
+    # try something out of signed range, it should clip
+    @trans.read(1000).should == ["\200\000\000\000\000\000\000\000",
+      "\377\377\364\303\035\244+]",
+      "\377\377\377\377\376\231:\341",
+      "\377\377\377\377\377\377\377\026",
+      "\000\000\000\000\000\000\000\000",
+      "\000\000\000\000\000\000\004\317",
+      "\000\000\000\000\000#\340\204",
+      "\000\000\000\002\340\311~\365",
+      "\177\377\377\377\377\377\377\377"].join("")
+    lambda { @prot.write_i64(2 ** 65 + 5) }.should raise_error(RangeError)
+  end
+  
+  it "should error gracefully when trying to write a nil i64" do
+    lambda { @prot.write_i64(nil) }.should raise_error
+  end
+  
+  it "should write a double" do
+    # try a random scattering of values, including min/max
+    values = [Float::MIN,-1231.15325, -123123.23, -23.23515123, 0, 12351.1325, 523.23, Float::MAX]
+    values.each do |f|
+      @prot.write_double(f)
+      @trans.read(1000).should == [f].pack("G")
+    end
+  end
+  
+  it "should error gracefully when trying to write a nil double" do
+    lambda { @prot.write_double(nil) }.should raise_error
+  end
+  
+  it "should write a string" do
+    str = "hello world"
+    @prot.write_string(str)
+    @trans.read(1000).should == [str.size].pack("N") + str
+  end
+  
+  it "should error gracefully when trying to write a nil string" do
+    lambda { @prot.write_string(nil) }.should raise_error
+  end
+  
+  # message footer is a noop
+  
+  it "should read a field header" do
+    @trans.write([Thrift::Types::STRING, 3].pack("cn"))
+    @prot.read_field_begin.should == [nil, Thrift::Types::STRING, 3]
+  end
+  
+  # field footer is a noop
+  
+  it "should read a stop field" do
+    @trans.write([Thrift::Types::STOP].pack("c"));
+    @prot.read_field_begin.should == [nil, Thrift::Types::STOP, 0]
+  end
+
+  it "should read a map header" do
+    @trans.write([Thrift::Types::DOUBLE, Thrift::Types::I64, 42].pack("ccN"))
+    @prot.read_map_begin.should == [Thrift::Types::DOUBLE, Thrift::Types::I64, 42]
+  end
+  
+  # map footer is a noop
+  
+  it "should read a list header" do
+    @trans.write([Thrift::Types::STRING, 17].pack("cN"))
+    @prot.read_list_begin.should == [Thrift::Types::STRING, 17]
+  end
+  
+  # list footer is a noop
+  
+  it "should read a set header" do
+    @trans.write([Thrift::Types::STRING, 17].pack("cN"))
+    @prot.read_set_begin.should == [Thrift::Types::STRING, 17]
+  end
+  
+  # set footer is a noop
+  
+  it "should read a bool" do
+    @trans.write("\001\000");
+    @prot.read_bool.should == true
+    @prot.read_bool.should == false
+  end
+  
+  it "should read a byte" do
+    [-128, -57, -3, 0, 17, 24, 127].each do |i|
+      @trans.write([i].pack("c"))
+      @prot.read_byte.should == i
+    end
+  end
+  
+  it "should read an i16" do
+    # try a scattering of values, including min/max
+    [-2**15, -5237, -353, 0, 1527, 2234, 2**15-1].each do |i|
+      @trans.write([i].pack("n"));
+      @prot.read_i16.should == i
+    end
+  end
+  
+  it "should read an i32" do
+    # try a scattering of values, including min/max
+    [-2**31, -235125, -6236, 0, 2351, 123123, 2**31-1].each do |i|
+      @trans.write([i].pack("N"))
+      @prot.read_i32.should == i
+    end
+  end
+  
+  it "should read an i64" do
+    # try a scattering of values, including min/max
+    [-2**63, -123512312, -6346, 0, 32, 2346322323, 2**63-1].each do |i|
+      @trans.write([i >> 32, i & 0xFFFFFFFF].pack("NN"))
+      @prot.read_i64.should == i
+    end
+  end
+  
+  it "should read a double" do
+    # try a random scattering of values, including min/max
+    [Float::MIN, -231231.12351, -323.233513, 0, 123.2351235, 2351235.12351235, Float::MAX].each do |f|
+      @trans.write([f].pack("G"));
+      @prot.read_double.should == f
+    end
+  end
+  
+  it "should read a string" do
+    str = "hello world"
+    @trans.write([str.size].pack("N") + str)
+    @prot.read_string.should == str
+  end
+end

data/spec/binaryprotocolaccelerated_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'thrift/protocol/binaryprotocolaccelerated'
+require File.dirname(__FILE__) + '/binaryprotocol_spec_shared'
+require File.dirname(__FILE__) + '/gen-rb/ThriftSpec_types'
+
+class ThriftBinaryProtocolAcceleratedSpec < Spec::ExampleGroup
+  include Thrift
+
+  describe Thrift::BinaryProtocolAccelerated do
+    # since BinaryProtocolAccelerated should be directly equivalent to 
+    # BinaryProtocol, we don't need any custom specs!
+    it_should_behave_like 'a binary protocol'
+
+    def protocol_class
+      BinaryProtocolAccelerated
+    end
+
+#     before(:each) do
+#       @buffer = ""
+#       @trans.stub!(:borrow).and_return { @buffer }
+#       @trans.stub!(:consume!).and_return do |*args|
+#         n = args.first || 0
+#         @buffer.slice!(0,n)
+#       end
+#     end
+# 
+# 
+#     it "should raise an exception if the message header has the wrong version" do
+#       @buffer = "\000\000\000\v"
+#       # @prot.should_receive(:read_i32).and_return(42)
+#       lambda { @prot.read_message_begin }.should raise_error(Thrift::ProtocolException, 'Missing version identifier') do |e|
+#         e.type == Thrift::ProtocolException::BAD_VERSION
+#       end
+#     end
+# 
+#     it "should encode a string with null bytes in it" do
+#       foo = SpecNamespace::Hello.new(:greeting => "Hello\000World!")
+#       @prot.encode_binary(foo).should == "\v\000\001\000\000\000\fHello\000World!\000"
+#     end
+# 
+#     it "should decode a string with null bytes in it" do
+#       trans = Thrift::MemoryBuffer.new("\v\000\001\000\000\000\fHello\000World!\000")
+#       @prot.decode_binary(SpecNamespace::Hello.new, trans).should == SpecNamespace::Hello.new(:greeting => "Hello\000World!")
+#     end
+# 
+#     it "should error when encoding a struct with a nil value in a list" do
+#       Thrift.type_checking = false
+#       sl = SpecNamespace::SimpleList
+#       hello = SpecNamespace::Hello
+#       # nil counts as false for bools
+#       # lambda { @prot.encode_binary(sl.new(:bools => [true, false, nil, false])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:bytes => [1, 2, nil, 3])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:i16s => [1, 2, nil, 3])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:i32s => [1, 2, nil, 3])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:i64s => [1, 2, nil, 3])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:doubles => [1.0, 2.0, nil, 3.0])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:strings => ["one", "two", nil, "three"])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:lists => [[1, 2], nil, [3, 4]])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:maps => [{1 => 2}, nil, {3 => 4}])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:sets => [Set.new([1, 2]), nil, Set.new([3, 4])])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:structs => [hello.new, nil, hello.new(:greeting => "hi")])) }.should raise_error
+#     end
+# 
+#     it "should error when encoding a non-nil, non-correctly-typed value in a list" do
+#       Thrift.type_checking = false
+#       sl = SpecNamespace::SimpleList
+#       hello = SpecNamespace::Hello
+#       # bool should accept any value
+#       # lambda { @prot.encode_binary(sl.new(:bools => [true, false, 3])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:bytes => [1, 2, "3", 5])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:i16s => ["one", 2, 3])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:i32s => [[1,2], 3, 4])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:i64s => [{1 => 2}, 3, 4])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:doubles => ["one", 2.3, 3.4])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:strings => ["one", "two", 3, 4])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:lists => [{1 => 2}, [3, 4]])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:maps => [{1 => 2}, [3, 4]])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:sets => [Set.new([1, 2]), 3, 4])) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:structs => [3, "four"])) }.should raise_error
+#     end
+# 
+#     it "should error when encoding an improper object where a container is expected" do
+#       Thrift.type_checking = false
+#       sl = SpecNamespace::SimpleList
+#       lambda { @prot.encode_binary(sl.new(:strings => {"one" => "two", nil => "three"})) }.should raise_error
+#       lambda { @prot.encode_binary(sl.new(:maps => [[1, 2]])) }.should raise_error
+#     end
+# 
+#     it "should accept arrays and hashes as sets" do
+#       Thrift.type_checking = false
+#       sl = SpecNamespace::SimpleList
+#       lambda { @prot.encode_binary(sl.new(:sets => [[1, 2], {3 => true, 4 => true}])) }.should_not raise_error
+#     end
+  end
+
+  describe BinaryProtocolAcceleratedFactory do
+    it "should create a BinaryProtocolAccelerated" do
+      BinaryProtocolAcceleratedFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(BinaryProtocolAccelerated)
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class ThriftClientSpec < Spec::ExampleGroup
+  include Thrift
+
+  class ClientSpec
+    include Thrift::Client
+  end
+
+  before(:each) do
+    @prot = mock("MockProtocol")
+    @client = ClientSpec.new(@prot)
+  end
+
+  describe Client do
+    it "should re-use iprot for oprot if not otherwise specified" do
+      @client.instance_variable_get(:'@iprot').should eql(@prot)
+      @client.instance_variable_get(:'@oprot').should eql(@prot)
+    end
+
+    it "should send a test message" do
+      @prot.should_receive(:write_message_begin).with('testMessage', MessageTypes::CALL, 0)
+      mock_args = mock('#<TestMessage_args:mock>')
+      mock_args.should_receive(:foo=).with('foo')
+      mock_args.should_receive(:bar=).with(42)
+      mock_args.should_receive(:write).with(@prot)
+      @prot.should_receive(:write_message_end)
+      @prot.should_receive(:trans) do
+        mock('trans').tee do |trans|
+          trans.should_receive(:flush)
+        end
+      end
+      klass = stub("TestMessage_args", :new => mock_args)
+      @client.send_message('testMessage', klass, :foo => 'foo', :bar => 42)
+    end
+
+    it "should increment the sequence id when sending messages" do
+      pending "it seems sequence ids are completely ignored right now" do
+        @prot.should_receive(:write_message_begin).with('testMessage',  MessageTypes::CALL, 0).ordered
+        @prot.should_receive(:write_message_begin).with('testMessage2', MessageTypes::CALL, 1).ordered
+        @prot.should_receive(:write_message_begin).with('testMessage3', MessageTypes::CALL, 2).ordered
+        @prot.stub!(:write_message_end)
+        @prot.stub!(:trans).and_return stub_everything("trans")
+        @client.send_message('testMessage', stub_everything("args class"))
+        @client.send_message('testMessage2', stub_everything("args class"))
+        @client.send_message('testMessage3', stub_everything("args class"))
+      end
+    end
+
+    it "should receive a test message" do
+      @prot.should_receive(:read_message_begin).and_return [nil, MessageTypes::CALL, 0]
+      @prot.should_receive(:read_message_end)
+      mock_klass = mock("#<MockClass:mock>")
+      mock_klass.should_receive(:read).with(@prot)
+      @client.receive_message(stub("MockClass", :new => mock_klass))
+    end
+
+    it "should handle received exceptions" do
+      @prot.should_receive(:read_message_begin).and_return [nil, MessageTypes::EXCEPTION, 0]
+      @prot.should_receive(:read_message_end)
+      ApplicationException.should_receive(:new).and_return do
+        StandardError.new.tee do |mock_exc|
+          mock_exc.should_receive(:read).with(@prot)
+        end
+      end
+      lambda { @client.receive_message(nil) }.should raise_error(StandardError)
+    end
+
+    it "should close the transport if an error occurs while sending a message" do
+      @prot.stub!(:write_message_begin)
+      @prot.should_not_receive(:write_message_end)
+      mock_args = mock("#<TestMessage_args:mock>")
+      mock_args.should_receive(:write).with(@prot).and_raise(StandardError)
+      trans = mock("MockTransport")
+      @prot.stub!(:trans).and_return(trans)
+      trans.should_receive(:close)
+      klass = mock("TestMessage_args", :new => mock_args)
+      lambda { @client.send_message("testMessage", klass) }.should raise_error(StandardError)
+    end
+  end
+end