Modified: incubator/thrift/trunk/lib/rb/spec/binaryprotocolaccelerated_spec.rb URL: http://svn.apache.org/viewvc/incubator/thrift/trunk/lib/rb/spec/binaryprotocolaccelerated_spec.rb?rev=739895&r1=739894&r2=739895&view=diff ============================================================================== --- incubator/thrift/trunk/lib/rb/spec/binaryprotocolaccelerated_spec.rb (original) +++ incubator/thrift/trunk/lib/rb/spec/binaryprotocolaccelerated_spec.rb Mon Feb 2 00:48:17 2009 @@ -6,133 +6,91 @@ class ThriftBinaryProtocolAcceleratedSpec < Spec::ExampleGroup include Thrift - describe BinaryProtocolAccelerated do - # given that BinaryProtocolAccelerated only actually overrides read_message_begin - # this shared spec isn't going to do much, but it's still worth including - # for future-proofing in case we start overriding individual methods + 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 read a message header" do - @buffer = "\200\001\000\002\000\000\000\vtestMessage\000\000\000*" - # @prot.should_receive(:read_i32).and_return(protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::REPLY, 42) - # @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 - @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 struct with all fields set identically to Thrift::BinaryProtocol" do - foo = SpecNamespace::Foo.new(:complex => {5 => {"foo" => 1.2}, 17 => {"bar" => 3.14159, "baz" => 5.8}}) - @prot.encode_binary(foo).should == "\r\000\005\b\r\000\000\000\002\000\000\000\005\v\004\000\000\000\001\000\ -\000\000\003foo?\363333333\000\000\000\021\v\004\000\000\000\002\000\000\000\003...@\027333333\000\000\000\003bar@\ -\t!\371\360\e\206n\016\000\006\006\000\000\000\003\000\005\000\021\000\357\b\000\001\000\000\0005\v\000\002\000\000\ -\000\005words\f\000\003\v\000\001\000\000\000\rhello, world!\000\017\000\004\b\000\000\000\004\000\000\000\001\000\ -\000\000\002\000\000\000\002\000\000\000\003\000" - end - - it "should encode a struct with missing fields identically to Thrift::BinaryProtocol" do - foo = SpecNamespace::Foo.new(:simple => nil, :ints => nil) - @prot.encode_binary(foo).should == "\016\000\006\006\000\000\000\003\000\005\000\021\000\357\v\000\002\000\000\ -\000\005words\f\000\003\v\000\001\000\000\000\rhello, world!\000\000" - end - - it "should decode a struct with all fields set identically to Thrift::BinaryProtocol" do - foo = SpecNamespace::Foo.new(:complex => {5 => {"foo" => 1.2}, 17 => {"bar" => 3.14159, "baz" => 5.8}}) - trans = Thrift::MemoryBuffer.new("\r\000\005\b\r\000\000\000\002\000\000\000\005\v\004\000\000\000\001\000\ -\000\000\003foo?\363333333\000\000\000\021\v\004\000\000\000\002\000\000\000\003...@\027333333\000\000\000\003bar@\ -\t!\371\360\e\206n\016\000\006\006\000\000\000\003\000\005\000\021\000\357\b\000\001\000\000\0005\v\000\002\000\000\ -\000\005words\f\000\003\v\000\001\000\000\000\rhello, world!\000\017\000\004\b\000\000\000\004\000\000\000\001\000\ -\000\000\002\000\000\000\002\000\000\000\003\000") - @prot.decode_binary(SpecNamespace::Foo.new, trans).should == foo - end - - it "should decode a struct with missing fields identically to Thrift::BinaryProtocol" do - trans = Thrift::MemoryBuffer.new("\016\000\006\006\000\000\000\003\000\005\000\021\000\357\v\000\002\000\000\ -\000\005words\f\000\003\v\000\001\000\000\000\rhello, world!\000\000") - @prot.decode_binary(SpecNamespace::Foo.new, trans).should == SpecNamespace::Foo.new - 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 given nil to encode" do - lambda { @prot.encode_binary(nil) }.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 +# 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
Modified: incubator/thrift/trunk/lib/rb/spec/protocol_spec.rb URL: http://svn.apache.org/viewvc/incubator/thrift/trunk/lib/rb/spec/protocol_spec.rb?rev=739895&r1=739894&r2=739895&view=diff ============================================================================== --- incubator/thrift/trunk/lib/rb/spec/protocol_spec.rb (original) +++ incubator/thrift/trunk/lib/rb/spec/protocol_spec.rb Mon Feb 2 00:48:17 2009 @@ -1,4 +1,5 @@ require File.dirname(__FILE__) + '/spec_helper' +require "thrift_native" class ThriftProtocolSpec < Spec::ExampleGroup include Thrift @@ -94,18 +95,23 @@ ['field 3', Types::MAP, 3], [nil, Types::STOP, 0] ) - @prot.should_receive(:skip).with(Types::STRING).ordered - @prot.should_receive(:skip).with(Types::I32).ordered - @prot.should_receive(:skip).with(Types::MAP).ordered @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_string).exactly(2).times + @prot.should_receive(:read_map_end).ordered @prot.should_receive(:read_struct_end).ordered real_skip.call(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, 7]) - @prot.should_receive(:skip).ordered.exactly(14).times # once per key and once per value + @prot.should_receive(:read_map_begin).ordered.and_return([Types::STRING, 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_struct_end).ordered @prot.should_receive(:read_map_end).ordered real_skip.call(Types::MAP) end @@ -113,7 +119,7 @@ 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(:skip).with(Types::I64).ordered.exactly(9).times + @prot.should_receive(:read_i64).ordered.exactly(9).times @prot.should_receive(:read_set_end) real_skip.call(Types::SET) end @@ -121,7 +127,7 @@ 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(:skip).with(Types::DOUBLE).ordered.exactly(11).times + @prot.should_receive(:read_double).ordered.exactly(11).times @prot.should_receive(:read_list_end) real_skip.call(Types::LIST) end Modified: incubator/thrift/trunk/lib/rb/spec/serializer_spec.rb URL: http://svn.apache.org/viewvc/incubator/thrift/trunk/lib/rb/spec/serializer_spec.rb?rev=739895&r1=739894&r2=739895&view=diff ============================================================================== --- incubator/thrift/trunk/lib/rb/spec/serializer_spec.rb (original) +++ incubator/thrift/trunk/lib/rb/spec/serializer_spec.rb Mon Feb 2 00:48:17 2009 @@ -8,15 +8,17 @@ describe Serializer do it "should serialize structs to binary by default" do - serializer = Serializer.new + 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" end it "should serialize structs to the given protocol" do - protocol = mock("Protocol") + protocol = Protocol.new(mock("transport")) protocol.should_receive(:write_struct_begin).with("SpecNamespace::Hello") - protocol.should_receive(:write_field).with("greeting", Types::STRING, 1, "Good day") + 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) protocolFactory = mock("ProtocolFactory") @@ -34,11 +36,11 @@ end it "should deserialize structs from the given protocol" do - protocol = mock("Protocol") + protocol = Protocol.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_type).with(Types::STRING).and_return("Good day") + protocol.should_receive(:read_string).and_return("Good day") protocol.should_receive(:read_field_end) protocol.should_receive(:read_struct_end) protocolFactory = mock("ProtocolFactory") Modified: incubator/thrift/trunk/lib/rb/spec/spec_helper.rb URL: http://svn.apache.org/viewvc/incubator/thrift/trunk/lib/rb/spec/spec_helper.rb?rev=739895&r1=739894&r2=739895&view=diff ============================================================================== --- incubator/thrift/trunk/lib/rb/spec/spec_helper.rb (original) +++ incubator/thrift/trunk/lib/rb/spec/spec_helper.rb Mon Feb 2 00:48:17 2009 @@ -31,3 +31,5 @@ Thrift.type_checking = true end end + +require "thrift_native" \ No newline at end of file Modified: incubator/thrift/trunk/lib/rb/spec/struct_spec.rb URL: http://svn.apache.org/viewvc/incubator/thrift/trunk/lib/rb/spec/struct_spec.rb?rev=739895&r1=739894&r2=739895&view=diff ============================================================================== --- incubator/thrift/trunk/lib/rb/spec/struct_spec.rb (original) +++ incubator/thrift/trunk/lib/rb/spec/struct_spec.rb Mon Feb 2 00:48:17 2009 @@ -1,6 +1,8 @@ require File.dirname(__FILE__) + '/spec_helper' require File.dirname(__FILE__) + '/gen-rb/ThriftSpec_types' +# require "binaryprotocolaccelerated" + class ThriftStructSpec < Spec::ExampleGroup include Thrift include SpecNamespace @@ -54,7 +56,7 @@ it "should read itself off the wire" do struct = Foo.new - prot = mock("Protocol") + prot = Protocol.new(mock("transport")) prot.should_receive(:read_struct_begin).twice prot.should_receive(:read_struct_end).twice prot.should_receive(:read_field_begin).and_return( @@ -79,14 +81,14 @@ prot.should_receive(:read_list_end) prot.should_receive(:read_set_begin).and_return([Types::I16, 2]) prot.should_receive(:read_set_end) - prot.should_receive(:read_type).with(Types::I32).and_return( + prot.should_receive(:read_i32).and_return( 1, 14, # complex keys 42, # simple 4, 23, 4, 29 # ints ) - prot.should_receive(:read_type).with(Types::STRING).and_return("pi", "e", "feigenbaum", "apple banana", "what's up?") - prot.should_receive(:read_type).with(Types::DOUBLE).and_return(Math::PI, Math::E, 4.669201609) - prot.should_receive(:read_type).with(Types::I16).and_return(2, 3) + prot.should_receive(:read_string).and_return("pi", "e", "feigenbaum", "apple banana", "what's up?") + prot.should_receive(:read_double).and_return(Math::PI, Math::E, 4.669201609) + prot.should_receive(:read_i16).and_return(2, 3) prot.should_not_receive(:skip) struct.read(prot) @@ -100,7 +102,7 @@ it "should skip unexpected fields in structs and use default values" do struct = Foo.new - prot = mock("Protocol") + prot = Protocol.new(mock("transport")) prot.should_receive(:read_struct_begin) prot.should_receive(:read_struct_end) prot.should_receive(:read_field_begin).and_return( @@ -112,10 +114,12 @@ [nil, Types::STOP, 0] ) prot.should_receive(:read_field_end).exactly(5).times - prot.should_receive(:read_type).with(Types::I32).and_return(42) - prot.should_receive(:read_type).with(Types::STRING).and_return("foobar") + prot.should_receive(:read_i32).and_return(42) + prot.should_receive(:read_string).and_return("foobar") prot.should_receive(:skip).with(Types::STRUCT) prot.should_receive(:skip).with(Types::MAP) + # prot.should_receive(:read_map_begin).and_return([Types::I32, Types::I32, 0]) + # prot.should_receive(:read_map_end) prot.should_receive(:skip).with(Types::I32) struct.read(prot) @@ -128,31 +132,35 @@ end it "should write itself to the wire" do - prot = mock("Protocol") + prot = Protocol.new(mock("transport")) #mock("Protocol") prot.should_receive(:write_struct_begin).with("SpecNamespace::Foo") - prot.should_receive(:write_struct_end) + prot.should_receive(:write_struct_begin).with("SpecNamespace::Hello") + prot.should_receive(:write_struct_end).twice prot.should_receive(:write_field_begin).with('ints', Types::LIST, 4) + prot.should_receive(:write_i32).with(1) + prot.should_receive(:write_i32).with(2).twice + prot.should_receive(:write_i32).with(3) prot.should_receive(:write_field_begin).with('complex', Types::MAP, 5) + prot.should_receive(:write_i32).with(5) + prot.should_receive(:write_string).with('foo') + prot.should_receive(:write_double).with(1.23) prot.should_receive(:write_field_begin).with('shorts', Types::SET, 6) - prot.should_receive(:write_field_stop) - prot.should_receive(:write_field_end).exactly(3).times - prot.should_receive(:write_field).with('simple', Types::I32, 1, 53) - prot.should_receive(:write_field).with('hello', Types::STRUCT, 3, Hello.new(:greeting => 'hello, world!')) + prot.should_receive(:write_i16).with(5) + prot.should_receive(:write_i16).with(17) + prot.should_receive(:write_i16).with(239) + prot.should_receive(:write_field_stop).twice + prot.should_receive(:write_field_end).exactly(6).times + prot.should_receive(:write_field_begin).with('simple', Types::I32, 1) + prot.should_receive(:write_i32).with(53) + prot.should_receive(:write_field_begin).with('hello', Types::STRUCT, 3) + prot.should_receive(:write_field_begin).with('greeting', Types::STRING, 1) + prot.should_receive(:write_string).with('hello, world!') prot.should_receive(:write_map_begin).with(Types::I32, Types::MAP, 1) prot.should_receive(:write_map_begin).with(Types::STRING, Types::DOUBLE, 1) - prot.should_receive(:write_type).with(Types::I32, 5) # complex/1/key - prot.should_receive(:write_type).with(Types::STRING, "foo") # complex/1/value/1/key - prot.should_receive(:write_type).with(Types::DOUBLE, 1.23) # complex/1/value/1/value prot.should_receive(:write_map_end).twice prot.should_receive(:write_list_begin).with(Types::I32, 4) - prot.should_receive(:write_type).with(Types::I32, 1) - prot.should_receive(:write_type).with(Types::I32, 2).twice - prot.should_receive(:write_type).with(Types::I32, 3) prot.should_receive(:write_list_end) prot.should_receive(:write_set_begin).with(Types::I16, 3) - prot.should_receive(:write_type).with(Types::I16, 5) - prot.should_receive(:write_type).with(Types::I16, 17) - prot.should_receive(:write_type).with(Types::I16, 239) prot.should_receive(:write_set_end) struct = Foo.new @@ -199,12 +207,15 @@ e.message.should == "something happened" e.code.should == 1 # ensure it gets serialized properly, this is the really important part - prot = mock("Protocol") + prot = Protocol.new(mock("trans")) prot.should_receive(:write_struct_begin).with("SpecNamespace::Xception") prot.should_receive(:write_struct_end) - prot.should_receive(:write_field).with('message', Types::STRING, 1, "something happened") - prot.should_receive(:write_field).with('code', Types::I32, 2, 1) + prot.should_receive(:write_field_begin).with('message', Types::STRING, 1)#, "something happened") + prot.should_receive(:write_string).with("something happened") + prot.should_receive(:write_field_begin).with('code', Types::I32, 2)#, 1) + prot.should_receive(:write_i32).with(1) prot.should_receive(:write_field_stop) + prot.should_receive(:write_field_end).twice e.write(prot) end @@ -216,12 +227,15 @@ rescue Thrift::Exception => e e.message.should == "something happened" e.code.should == 5 - prot = mock("Protocol") + prot = Protocol.new(mock("trans")) prot.should_receive(:write_struct_begin).with("SpecNamespace::Xception") prot.should_receive(:write_struct_end) - prot.should_receive(:write_field).with('message', Types::STRING, 1, "something happened") - prot.should_receive(:write_field).with('code', Types::I32, 2, 5) + prot.should_receive(:write_field_begin).with('message', Types::STRING, 1) + prot.should_receive(:write_string).with("something happened") + prot.should_receive(:write_field_begin).with('code', Types::I32, 2) + prot.should_receive(:write_i32).with(5) prot.should_receive(:write_field_stop) + prot.should_receive(:write_field_end).twice e.write(prot) end
