thrift 0.9.2.0 → 0.14.0

data/spec/binary_protocol_accelerated_spec.rb

@@ -33,10 +33,14 @@ if defined? Thrift::BinaryProtocolAccelerated
 
     describe Thrift::BinaryProtocolAcceleratedFactory do
       it "should create a BinaryProtocolAccelerated" do
-        Thrift::BinaryProtocolAcceleratedFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(Thrift::BinaryProtocolAccelerated)
+        expect(Thrift::BinaryProtocolAcceleratedFactory.new.get_protocol(double("MockTransport"))).to be_instance_of(Thrift::BinaryProtocolAccelerated)
+      end
+
+      it "should provide a reasonable to_s" do
+        expect(Thrift::BinaryProtocolAcceleratedFactory.new.to_s).to eq("binary-accel")
       end
     end
   end
 else
   puts "skipping BinaryProtocolAccelerated spec because it is not defined."
-end
+end

data/spec/binary_protocol_spec.rb

@@ -38,29 +38,37 @@ describe 'BinaryProtocol' do
     it "should read a message header" do
       @trans.write([protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::REPLY].pack('N'))
       @trans.write([42].pack('N'))
-      @prot.should_receive(:read_string).and_return('testMessage')
-      @prot.read_message_begin.should == ['testMessage', Thrift::MessageTypes::REPLY, 42]
+      expect(@prot).to receive(:read_string).and_return('testMessage')
+      expect(@prot.read_message_begin).to eq(['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|
+      expect(@prot).to receive(:read_i32).and_return(-1)
+      expect { @prot.read_message_begin }.to 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|
+      expect(@prot).to receive(:read_i32).and_return(42)
+      expect(@prot).to receive(:strict_read).and_return(true)
+      expect { @prot.read_message_begin }.to raise_error(Thrift::ProtocolException, 'No version identifier, old protocol client?') do |e|
         e.type == Thrift::ProtocolException::BAD_VERSION
       end
     end
+
+    it "should provide a reasonable to_s" do
+      expect(@prot.to_s).to eq("binary(memory)")
+    end
   end
 
   describe Thrift::BinaryProtocolFactory do
     it "should create a BinaryProtocol" do
-      Thrift::BinaryProtocolFactory.new.get_protocol(mock("MockTransport")).should be_instance_of(Thrift::BinaryProtocol)
+      expect(Thrift::BinaryProtocolFactory.new.get_protocol(double("MockTransport"))).to be_instance_of(Thrift::BinaryProtocol)
+    end
+
+    it "should provide a reasonable to_s" do
+      expect(Thrift::BinaryProtocolFactory.new.to_s).to eq("binary")
     end
   end
 end

data/spec/binary_protocol_spec_shared.rb

@@ -27,34 +27,34 @@ shared_examples_for 'a binary protocol' do
   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
+    expect(protocol_class.const_get(:VERSION_MASK)).to eq(0xffff0000)
+    expect(protocol_class.const_get(:VERSION_1)).to eq(0x80010000)
+    expect(protocol_class.const_get(:TYPE_MASK)).to eq(0x000000ff)
   end
 
   it "should make strict_read readable" do
-    @prot.strict_read.should eql(true)
+    expect(@prot.strict_read).to eql(true)
   end
 
   it "should make strict_write readable" do
-    @prot.strict_write.should eql(true)
+    expect(@prot.strict_write).to eql(true)
   end    
 
   it "should write the message header" do
     @prot.write_message_begin('testMessage', Thrift::MessageTypes::CALL, 17)
-    @trans.read(@trans.available).should == [protocol_class.const_get(:VERSION_1) | Thrift::MessageTypes::CALL, "testMessage".size, "testMessage", 17].pack("NNa11N")
+    expect(@trans.read(@trans.available)).to eq([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(@trans.available).should == "\000\000\000\vtestMessage\001\000\000\000\021"
+    expect(@trans.read(@trans.available)).to eq("\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(@trans.available).should == "\200\001\000\001\000\000\000\vtestMessage\000\000\000\021"
+    expect(@trans.read(@trans.available)).to eq("\200\001\000\001\000\000\000\vtestMessage\000\000\000\021")
   end
   
 
@@ -62,64 +62,67 @@ shared_examples_for 'a binary protocol' do
 
   it "should write the field header" do
     @prot.write_field_begin('foo', Thrift::Types::DOUBLE, 3)
-    @trans.read(@trans.available).should == [Thrift::Types::DOUBLE, 3].pack("cn")
+    expect(@trans.read(@trans.available)).to eq([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"
+    expect(@trans.read(1)).to eq("\000")
   end
   
   it "should write the map header" do
     @prot.write_map_begin(Thrift::Types::STRING, Thrift::Types::LIST, 17)
-    @trans.read(@trans.available).should == [Thrift::Types::STRING, Thrift::Types::LIST, 17].pack("ccN");
+    expect(@trans.read(@trans.available)).to eq([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(@trans.available).should == [Thrift::Types::I16, 42].pack("cN")
+    expect(@trans.read(@trans.available)).to eq([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(@trans.available).should == [Thrift::Types::I16, 42].pack("cN")
+    expect(@trans.read(@trans.available)).to eq([Thrift::Types::I16, 42].pack("cN"))
   end
   
   it "should write a bool" do
     @prot.write_bool(true)
     @prot.write_bool(false)
-    @trans.read(@trans.available).should == "\001\000"
+    expect(@trans.read(@trans.available)).to eq("\001\000")
   end
   
   it "should treat a nil bool as false" do
     @prot.write_bool(nil)
-    @trans.read(1).should == "\000"
+    expect(@trans.read(1)).to eq("\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')
+      expect(@trans.read(1)).to eq([i].pack('c'))
     end
-    # handing it numbers out of signed range should clip
-    @trans.rspec_verify
+  end
+
+  it "should clip numbers out of signed range" do
     (128..255).each do |i|
       @prot.write_byte(i)
-      @trans.read(1).should == [i].pack('c')
+      expect(@trans.read(1)).to eq([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 "errors out with a Bignum" do
+    expect { @prot.write_byte(2**65) }.to raise_error(RangeError)
   end
   
   it "should error gracefully when trying to write a nil byte" do
-    lambda { @prot.write_byte(nil) }.should raise_error
+    expect { @prot.write_byte(nil) }.to raise_error
   end
   
   it "should write an i16" do
@@ -131,14 +134,14 @@ shared_examples_for 'a binary protocol' do
     # and try something out of signed range, it should clip
     @prot.write_i16(2**15 + 5)
     
-    @trans.read(@trans.available).should == "\200\000\374\000\000\021\000\000\330\360\006\273\177\377\200\005"
+    expect(@trans.read(@trans.available)).to eq("\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
+    expect { @prot.write_i16(nil) }.to raise_error
   end
   
   it "should write an i32" do
@@ -148,14 +151,14 @@ shared_examples_for 'a binary protocol' do
       @prot.write_i32(i)
     end
     # try something out of signed range, it should clip
-    @trans.read(@trans.available).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"
+    expect(@trans.read(@trans.available)).to eq("\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)  
+      expect { @prot.write_i32(i) }.to 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
+    expect { @prot.write_i32(nil) }.to raise_error
   end
   
   it "should write an i64" do
@@ -165,7 +168,7 @@ shared_examples_for 'a binary protocol' do
       @prot.write_i64(i)
     end
     # try something out of signed range, it should clip
-    @trans.read(@trans.available).should == ["\200\000\000\000\000\000\000\000",
+    expect(@trans.read(@trans.available)).to eq(["\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",
@@ -173,12 +176,12 @@ shared_examples_for 'a binary protocol' do
       "\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)
+      "\177\377\377\377\377\377\377\377"].join(""))
+    expect { @prot.write_i64(2 ** 65 + 5) }.to raise_error(RangeError)
   end
   
   it "should error gracefully when trying to write a nil i64" do
-    lambda { @prot.write_i64(nil) }.should raise_error
+    expect { @prot.write_i64(nil) }.to raise_error
   end
   
   it "should write a double" do
@@ -186,12 +189,12 @@ shared_examples_for 'a binary protocol' do
     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(@trans.available).should == [f].pack("G")
+      expect(@trans.read(@trans.available)).to eq([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
+    expect { @prot.write_double(nil) }.to raise_error
   end
 
   if RUBY_VERSION >= '1.9'
@@ -199,111 +202,111 @@ shared_examples_for 'a binary protocol' do
       str = 'abc'
       @prot.write_string(str)
       a = @trans.read(@trans.available)
-      a.encoding.should == Encoding::BINARY
-      a.unpack('C*').should == [0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63]
+      expect(a.encoding).to eq(Encoding::BINARY)
+      expect(a.unpack('C*')).to eq([0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63])
     end
 
     it 'should write a string with unicode characters' do
       str = "abc \u20AC \u20AD".encode('UTF-8')
       @prot.write_string(str)
       a = @trans.read(@trans.available)
-      a.encoding.should == Encoding::BINARY
-      a.unpack('C*').should == [0x00, 0x00, 0x00, 0x0B, 0x61, 0x62, 0x63, 0x20,
-                                0xE2, 0x82, 0xAC, 0x20, 0xE2, 0x82, 0xAD]
+      expect(a.encoding).to eq(Encoding::BINARY)
+      expect(a.unpack('C*')).to eq([0x00, 0x00, 0x00, 0x0B, 0x61, 0x62, 0x63, 0x20,
+                                0xE2, 0x82, 0xAC, 0x20, 0xE2, 0x82, 0xAD])
     end
 
     it 'should write should write a string with unicode characters and transcoding' do
       str = "abc \u20AC".encode('ISO-8859-15')
       @prot.write_string(str)
       a = @trans.read(@trans.available)
-      a.encoding.should == Encoding::BINARY
-      a.unpack('C*').should == [0x00, 0x00, 0x00, 0x07, 0x61, 0x62, 0x63, 0x20, 0xE2, 0x82, 0xAC]
+      expect(a.encoding).to eq(Encoding::BINARY)
+      expect(a.unpack('C*')).to eq([0x00, 0x00, 0x00, 0x07, 0x61, 0x62, 0x63, 0x20, 0xE2, 0x82, 0xAC])
     end
 
     it 'should write a binary string' do
       buffer = [0, 1, 2, 3].pack('C*')
       @prot.write_binary(buffer)
       a = @trans.read(@trans.available)
-      a.encoding.should == Encoding::BINARY
-      a.unpack('C*').should == [0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03]
+      expect(a.encoding).to eq(Encoding::BINARY)
+      expect(a.unpack('C*')).to eq([0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03])
     end
   else
     it 'should write a string' do
       str = 'abc'
       @prot.write_string(str)
       a = @trans.read(@trans.available)
-      a.unpack('C*').should == [0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63]
+      expect(a.unpack('C*')).to eq([0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63])
     end
 
     it 'should write a binary string' do
       buffer = [0, 1, 2, 3].pack('C*')
       @prot.write_binary(buffer)
       a = @trans.read(@trans.available)
-      a.unpack('C*').should == [0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03]
+      expect(a.unpack('C*')).to eq([0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03])
     end
   end
 
   it "should error gracefully when trying to write a nil string" do
-    lambda { @prot.write_string(nil) }.should raise_error
+    expect { @prot.write_string(nil) }.to raise_error
   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(@trans.available).should == "\000\000\000\vtestMessage\001\000\000\000\021"
+    expect(@trans.read(@trans.available)).to eq("\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(@trans.available).should == "\200\001\000\001\000\000\000\vtestMessage\000\000\000\021"
+    expect(@trans.read(@trans.available)).to eq("\200\001\000\001\000\000\000\vtestMessage\000\000\000\021")
   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]
+    expect(@prot.read_field_begin).to eq([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]
+    expect(@prot.read_field_begin).to eq([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]
+    expect(@prot.read_map_begin).to eq([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]
+    expect(@prot.read_list_begin).to eq([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]
+    expect(@prot.read_set_begin).to eq([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
+    expect(@prot.read_bool).to eq(true)
+    expect(@prot.read_bool).to eq(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
+      expect(@prot.read_byte).to eq(i)
     end
   end
   
@@ -311,7 +314,7 @@ shared_examples_for 'a binary protocol' 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
+      expect(@prot.read_i16).to eq(i)
     end
   end
   
@@ -319,7 +322,7 @@ shared_examples_for 'a binary protocol' 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
+      expect(@prot.read_i32).to eq(i)
     end
   end
   
@@ -327,7 +330,7 @@ shared_examples_for 'a binary protocol' 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
+      expect(@prot.read_i64).to eq(i)
     end
   end
   
@@ -335,7 +338,7 @@ shared_examples_for 'a binary protocol' 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
+      expect(@prot.read_double).to eq(f)
     end
   end
 
@@ -345,8 +348,8 @@ shared_examples_for 'a binary protocol' do
       buffer = [0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63].pack('C*')
       @trans.write(buffer)
       a = @prot.read_string
-      a.should == 'abc'.encode('UTF-8')
-      a.encoding.should == Encoding::UTF_8
+      expect(a).to eq('abc'.encode('UTF-8'))
+      expect(a.encoding).to eq(Encoding::UTF_8)
     end
 
     it 'should read a string containing unicode characters from UTF-8 encoded buffer' do
@@ -354,44 +357,44 @@ shared_examples_for 'a binary protocol' do
       buffer = [0x00, 0x00, 0x00, 0x03, 0xE2, 0x82, 0xAC].pack('C*')
       @trans.write(buffer)
       a = @prot.read_string
-      a.should == "\u20AC".encode('UTF-8')
-      a.encoding.should == Encoding::UTF_8
+      expect(a).to eq("\u20AC".encode('UTF-8'))
+      expect(a.encoding).to eq(Encoding::UTF_8)
     end
 
     it 'should read a binary string' do
       buffer = [0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03].pack('C*')
       @trans.write(buffer)
       a = @prot.read_binary
-      a.should == [0x00, 0x01, 0x02, 0x03].pack('C*')
-      a.encoding.should == Encoding::BINARY
+      expect(a).to eq([0x00, 0x01, 0x02, 0x03].pack('C*'))
+      expect(a.encoding).to eq(Encoding::BINARY)
     end
   else
     it 'should read a string' do
       # i32 of value 3, followed by three characters/UTF-8 bytes 'a', 'b', 'c'
       buffer = [0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63].pack('C*')
       @trans.write(buffer)
-      @prot.read_string.should == 'abc'
+      expect(@prot.read_string).to eq('abc')
     end
 
     it 'should read a binary string' do
       buffer = [0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03].pack('C*')
       @trans.write(buffer)
       a = @prot.read_binary
-      a.should == [0x00, 0x01, 0x02, 0x03].pack('C*')
+      expect(a).to eq([0x00, 0x01, 0x02, 0x03].pack('C*'))
     end
   end
 
   it "should perform a complete rpc with no args or return" do
     srv_test(
       proc {|client| client.send_voidMethod()},
-      proc {|client| client.recv_voidMethod.should == nil}
+      proc {|client| expect(client.recv_voidMethod).to eq(nil)}
     )
   end
 
   it "should perform a complete rpc with a primitive return type" do
     srv_test(
       proc {|client| client.send_primitiveMethod()},
-      proc {|client| client.recv_primitiveMethod.should == 1}
+      proc {|client| expect(client.recv_primitiveMethod).to eq(1)}
     )
   end
 
@@ -402,7 +405,7 @@ shared_examples_for 'a binary protocol' do
         result = client.recv_structMethod
         result.set_byte_map = nil
         result.map_byte_map = nil
-        result.should == Fixtures::COMPACT_PROTOCOL_TEST_STRUCT
+        expect(result).to eq(Fixtures::COMPACT_PROTOCOL_TEST_STRUCT)
       }
     )
   end
@@ -423,9 +426,9 @@ shared_examples_for 'a binary protocol' do
     clientproto = protocol_class.new(clientside)
     serverproto = protocol_class.new(serverside)
 
-    processor = Srv::Processor.new(SrvHandler.new)
+    processor = Thrift::Test::Srv::Processor.new(SrvHandler.new)
 
-    client = Srv::Client.new(clientproto, clientproto)
+    client = Thrift::Test::Srv::Client.new(clientproto, clientproto)
 
     # first block
     firstblock.call(client)