You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@thrift.apache.org by br...@apache.org on 2009/02/02 01:48:17 UTC
svn commit: r739895 [2/2] - in /incubator/thrift/trunk/lib/rb: ./ ext/
lib/thrift/ lib/thrift/protocol/ spec/
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\003baz@\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\003baz@\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