thrift 0.9.2.0 → 0.14.0

data/spec/socket_spec.rb

@@ -25,37 +25,44 @@ describe 'Socket' do
   describe Thrift::Socket do
     before(:each) do
       @socket = Thrift::Socket.new
-      @handle = mock("Handle", :closed? => false)
-      @handle.stub!(:close)
-      @handle.stub!(:connect_nonblock)
-      @handle.stub!(:setsockopt)
-      ::Socket.stub!(:new).and_return(@handle)
+      @handle = double("Handle", :closed? => false)
+      allow(@handle).to receive(:close)
+      allow(@handle).to receive(:connect_nonblock)
+      allow(@handle).to receive(:setsockopt)
+      allow(::Socket).to receive(:new).and_return(@handle)
     end
 
     it_should_behave_like "a socket"
 
     it "should raise a TransportException when it cannot open a socket" do
-      ::Socket.should_receive(:new).and_raise(StandardError)
-      lambda { @socket.open }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
+      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
     end
 
     it "should open a ::Socket with default args" do
-      ::Socket.should_receive(:new).and_return(mock("Handle", :connect_nonblock => true, :setsockopt => nil))
-      ::Socket.should_receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      ::Socket.should_receive(:sockaddr_in)
+      expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
+      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
+      expect(::Socket).to receive(:sockaddr_in)
+      @socket.to_s == "socket(localhost:9090)"
       @socket.open
     end
 
     it "should accept host/port options" do
-      ::Socket.should_receive(:new).and_return(mock("Handle", :connect_nonblock => true, :setsockopt => nil))
-      ::Socket.should_receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
-      ::Socket.should_receive(:sockaddr_in)
-      Thrift::Socket.new('my.domain', 1234).open
+      expect(::Socket).to receive(:new).and_return(double("Handle", :connect_nonblock => true, :setsockopt => nil))
+      expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
+      expect(::Socket).to receive(:sockaddr_in)
+      @socket = Thrift::Socket.new('my.domain', 1234).open
+      @socket.to_s == "socket(my.domain:1234)"
     end
 
     it "should accept an optional timeout" do
-      ::Socket.stub!(:new)
-      Thrift::Socket.new('localhost', 8080, 5).timeout.should == 5
+      allow(::Socket).to receive(:new)
+      expect(Thrift::Socket.new('localhost', 8080, 5).timeout).to eq(5)
+    end
+
+    it "should provide a reasonable to_s" do
+      allow(::Socket).to receive(:new)
+      expect(Thrift::Socket.new('myhost', 8090).to_s).to eq("socket(myhost:8090)")
     end
   end
 end

data/spec/socket_spec_shared.rb

@@ -21,84 +21,84 @@ require 'spec_helper'
 
 shared_examples_for "a socket" do
   it "should open a socket" do
-    @socket.open.should == @handle
+    expect(@socket.open).to eq(@handle)
   end
 
   it "should be open whenever it has a handle" do
-    @socket.should_not be_open
+    expect(@socket).not_to be_open
     @socket.open
-    @socket.should be_open
+    expect(@socket).to be_open
     @socket.handle = nil
-    @socket.should_not be_open
+    expect(@socket).not_to be_open
     @socket.handle = @handle
     @socket.close
-    @socket.should_not be_open
+    expect(@socket).not_to be_open
   end
 
   it "should write data to the handle" do
     @socket.open
-    @handle.should_receive(:write).with("foobar")
+    expect(@handle).to receive(:write).with("foobar")
     @socket.write("foobar")
-    @handle.should_receive(:write).with("fail").and_raise(StandardError)
-    lambda { @socket.write("fail") }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+    expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
+    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
   end
 
   it "should raise an error when it cannot read from the handle" do
     @socket.open
-    @handle.should_receive(:readpartial).with(17).and_raise(StandardError)
-    lambda { @socket.read(17) }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::NOT_OPEN }
+    expect(@handle).to receive(:readpartial).with(17).and_raise(StandardError)
+    expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
   end
 
   it "should return the data read when reading from the handle works" do
     @socket.open
-    @handle.should_receive(:readpartial).with(17).and_return("test data")
-    @socket.read(17).should == "test data"
+    expect(@handle).to receive(:readpartial).with(17).and_return("test data")
+    expect(@socket.read(17)).to eq("test data")
   end
 
   it "should declare itself as closed when it has an error" do
     @socket.open
-    @handle.should_receive(:write).with("fail").and_raise(StandardError)
-    @socket.should be_open
-    lambda { @socket.write("fail") }.should raise_error
-    @socket.should_not be_open
+    expect(@handle).to receive(:write).with("fail").and_raise(StandardError)
+    expect(@socket).to be_open
+    expect { @socket.write("fail") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
+    expect(@socket).not_to be_open
   end
 
   it "should raise an error when the stream is closed" do
     @socket.open
-    @handle.stub!(:closed?).and_return(true)
-    @socket.should_not be_open
-    lambda { @socket.write("fail") }.should raise_error(IOError, "closed stream")
-    lambda { @socket.read(10) }.should raise_error(IOError, "closed stream")
+    allow(@handle).to receive(:closed?).and_return(true)
+    expect(@socket).not_to be_open
+    expect { @socket.write("fail") }.to raise_error(IOError, "closed stream")
+    expect { @socket.read(10) }.to raise_error(IOError, "closed stream")
   end
 
   it "should support the timeout accessor for read" do
     @socket.timeout = 3
     @socket.open
-    IO.should_receive(:select).with([@handle], nil, nil, 3).and_return([[@handle], [], []])
-    @handle.should_receive(:readpartial).with(17).and_return("test data")
-    @socket.read(17).should == "test data"
+    expect(IO).to receive(:select).with([@handle], nil, nil, 3).and_return([[@handle], [], []])
+    expect(@handle).to receive(:readpartial).with(17).and_return("test data")
+    expect(@socket.read(17)).to eq("test data")
   end
 
   it "should support the timeout accessor for write" do
     @socket.timeout = 3
     @socket.open
-    IO.should_receive(:select).with(nil, [@handle], nil, 3).twice.and_return([[], [@handle], []])
-    @handle.should_receive(:write_nonblock).with("test data").and_return(4)
-    @handle.should_receive(:write_nonblock).with(" data").and_return(5)
-    @socket.write("test data").should == 9
+    expect(IO).to receive(:select).with(nil, [@handle], nil, 3).twice.and_return([[], [@handle], []])
+    expect(@handle).to receive(:write_nonblock).with("test data").and_return(4)
+    expect(@handle).to receive(:write_nonblock).with(" data").and_return(5)
+    expect(@socket.write("test data")).to eq(9)
   end
 
   it "should raise an error when read times out" do
     @socket.timeout = 0.5
     @socket.open
-    IO.should_receive(:select).once {sleep(0.5); nil}
-    lambda { @socket.read(17) }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::TIMED_OUT }
+    expect(IO).to receive(:select).once {sleep(0.5); nil}
+    expect { @socket.read(17) }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
   end
 
   it "should raise an error when write times out" do
     @socket.timeout = 0.5
     @socket.open
-    IO.should_receive(:select).with(nil, [@handle], nil, 0.5).any_number_of_times.and_return(nil)
-    lambda { @socket.write("test data") }.should raise_error(Thrift::TransportException) { |e| e.type.should == Thrift::TransportException::TIMED_OUT }
+    allow(IO).to receive(:select).with(nil, [@handle], nil, 0.5).and_return(nil)
+    expect { @socket.write("test data") }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::TIMED_OUT) }
   end
 end

data/spec/spec_helper.rb

@@ -54,8 +54,11 @@ require 'thrift_spec_types'
 require 'nonblocking_service'
 
 module Fixtures
-  COMPACT_PROTOCOL_TEST_STRUCT = COMPACT_TEST.dup
+  COMPACT_PROTOCOL_TEST_STRUCT = Thrift::Test::COMPACT_TEST.dup
   COMPACT_PROTOCOL_TEST_STRUCT.a_binary = [0,1,2,3,4,5,6,7,8].pack('c*')
   COMPACT_PROTOCOL_TEST_STRUCT.set_byte_map = nil
   COMPACT_PROTOCOL_TEST_STRUCT.map_byte_map = nil
 end
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[gen-rb/flat])
+

data/spec/ssl_server_socket_spec.rb

@@ -0,0 +1,34 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+require 'spec_helper'
+require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
+
+describe 'SSLServerSocket' do
+
+  describe Thrift::SSLServerSocket do
+    before(:each) do
+      @socket = Thrift::SSLServerSocket.new(1234)
+    end
+
+    it "should provide a reasonable to_s" do
+      expect(@socket.to_s).to eq("ssl(socket(:1234))")
+    end
+  end
+end

data/spec/ssl_socket_spec.rb

@@ -0,0 +1,78 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+require 'spec_helper'
+require File.expand_path("#{File.dirname(__FILE__)}/socket_spec_shared")
+
+describe 'SSLSocket' do
+
+  describe Thrift::SSLSocket do
+    before(:each) do
+      @context = OpenSSL::SSL::SSLContext.new
+      @socket = Thrift::SSLSocket.new
+      @simple_socket_handle = double("Handle", :closed? => false)
+      allow(@simple_socket_handle).to receive(:close)
+      allow(@simple_socket_handle).to receive(:connect_nonblock)
+      allow(@simple_socket_handle).to receive(:setsockopt)
+
+      @handle = double(double("SSLHandle", :connect_nonblock => true, :post_connection_check => true), :closed? => false)
+      allow(@handle).to receive(:connect_nonblock)
+      allow(@handle).to receive(:close)
+      allow(@handle).to receive(:post_connection_check)
+
+      allow(::Socket).to receive(:new).and_return(@simple_socket_handle)
+      allow(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(@handle)
+    end
+
+    it_should_behave_like "a socket"
+
+    it "should raise a TransportException when it cannot open a ssl socket" do
+      expect(::Socket).to receive(:getaddrinfo).with("localhost", 9090, nil, ::Socket::SOCK_STREAM).and_return([[]])
+      expect { @socket.open }.to raise_error(Thrift::TransportException) { |e| expect(e.type).to eq(Thrift::TransportException::NOT_OPEN) }
+    end
+
+    it "should open a ::Socket with default args" do
+      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(@simple_socket_handle, nil).and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('localhost')
+      @socket.open
+    end
+
+    it "should accept host/port options" do
+      handle = double("Handle", :connect_nonblock => true, :setsockopt => nil)
+      allow(::Socket).to receive(:new).and_return(handle)
+      expect(::Socket).to receive(:getaddrinfo).with("my.domain", 1234, nil, ::Socket::SOCK_STREAM).and_return([[]])
+      expect(::Socket).to receive(:sockaddr_in)
+      expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(handle, nil).and_return(@handle)
+      expect(@handle).to receive(:post_connection_check).with('my.domain')
+      Thrift::SSLSocket.new('my.domain', 1234, 6000, nil).open
+    end
+
+    it "should accept an optional timeout" do
+      expect(Thrift::SSLSocket.new('localhost', 8080, 5).timeout).to eq(5)
+    end
+
+    it "should accept an optional context" do
+      expect(Thrift::SSLSocket.new('localhost', 8080, 5, @context).ssl_context).to eq(@context)
+    end
+
+    it "should provide a reasonable to_s" do
+      expect(Thrift::SSLSocket.new('myhost', 8090).to_s).to eq("ssl(socket(myhost:8090))")
+    end
+  end
+end

data/spec/struct_nested_containers_spec.rb

@@ -39,9 +39,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = [ [1, 2, 3], [2, 3, 4] ]
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value.push [3, 4, 5]
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -52,9 +52,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = [ [1, 2, 3], [2, 3, 4] ].to_set
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value.add [3, 4, 5]
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -65,9 +65,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = { [1, 2, 3] => 1, [2, 3, 4] => 2 }
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value[[3, 4, 5]] = 3
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -78,9 +78,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = { 1 => [1, 2, 3], 2 => [2, 3, 4] }
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value[3] = [3, 4, 5]
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -91,9 +91,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = [ [1, 2, 3].to_set, [2, 3, 4].to_set ]
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value.push([3, 4, 5].to_set)
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -104,9 +104,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = [ [1, 2, 3].to_set, [2, 3, 4].to_set ].to_set
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value.add([3, 4, 5].to_set)
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -117,9 +117,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = { [1, 2, 3].to_set => 1, [2, 3, 4].to_set => 2 }
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value[[3, 4, 5].to_set] = 3
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -130,9 +130,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = { 1 => [1, 2, 3].to_set, 2 => [2, 3, 4].to_set }
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value[3] = [3, 4, 5].to_set
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -143,9 +143,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = [ {1 => 2, 3 => 4}, {2 => 3, 4 => 5} ]
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value.push({ 3 => 4, 5 => 6 })
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -156,9 +156,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = [ {1 => 2, 3 => 4}, {2 => 3, 4 => 5} ].to_set
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value.add({ 3 => 4, 5 => 6 })
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -169,9 +169,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = { { 1 => 2, 3 => 4} => 1, {2 => 3, 4 => 5}  => 2 }
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value[{3 => 4, 5 => 6}] = 3
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
 
@@ -182,9 +182,9 @@ describe 'StructNestedContainers' do
           thrift_struct.value = { 1 => { 1 => 2, 3 => 4}, 2 => {2 => 3, 4 => 5} }
           thrift_struct.validate
         end
-        a.should == b
+        expect(a).to eq(b)
         b.value[3] = { 3 => 4, 5 => 6 }
-        a.should_not == b
+        expect(a).not_to eq(b)
       end
     end
   end

data/spec/struct_spec.rb

@@ -25,7 +25,7 @@ describe 'Struct' do
     it "should iterate over all fields properly" do
       fields = {}
       SpecNamespace::Foo.new.each_field { |fid,field_info| fields[fid] = field_info }
-      fields.should == SpecNamespace::Foo::FIELDS
+      expect(fields).to eq(SpecNamespace::Foo::FIELDS)
     end
 
     it "should initialize all fields to defaults" do
@@ -39,19 +39,19 @@ describe 'Struct' do
     end
 
     def validate_default_arguments(object)
-      object.simple.should == 53
-      object.words.should == "words"
-      object.hello.should == SpecNamespace::Hello.new(:greeting => 'hello, world!')
-      object.ints.should == [1, 2, 2, 3]
-      object.complex.should be_nil
-      object.shorts.should == Set.new([5, 17, 239])
+      expect(object.simple).to eq(53)
+      expect(object.words).to eq("words")
+      expect(object.hello).to eq(SpecNamespace::Hello.new(:greeting => 'hello, world!'))
+      expect(object.ints).to eq([1, 2, 2, 3])
+      expect(object.complex).to be_nil
+      expect(object.shorts).to eq(Set.new([5, 17, 239]))
     end
 
     it "should not share default values between instances" do
       begin
         struct = SpecNamespace::Foo.new
         struct.ints << 17
-        SpecNamespace::Foo.new.ints.should == [1,2,2,3]
+        expect(SpecNamespace::Foo.new.ints).to eq([1,2,2,3])
       ensure
         # ensure no leakage to other tests
         SpecNamespace::Foo::FIELDS[4][:default] = [1,2,2,3]
@@ -60,48 +60,48 @@ describe 'Struct' do
 
     it "should properly initialize boolean values" do
       struct = SpecNamespace::BoolStruct.new(:yesno => false)
-      struct.yesno.should be_false
+      expect(struct.yesno).to be_falsey
     end
 
     it "should have proper == semantics" do
-      SpecNamespace::Foo.new.should_not == SpecNamespace::Hello.new
-      SpecNamespace::Foo.new.should == SpecNamespace::Foo.new
-      SpecNamespace::Foo.new(:simple => 52).should_not == SpecNamespace::Foo.new
+      expect(SpecNamespace::Foo.new).not_to eq(SpecNamespace::Hello.new)
+      expect(SpecNamespace::Foo.new).to eq(SpecNamespace::Foo.new)
+      expect(SpecNamespace::Foo.new(:simple => 52)).not_to eq(SpecNamespace::Foo.new)
     end
 
     it "should print enum value names in inspect" do
-      SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect.should == "<SpecNamespace::StructWithSomeEnum some_enum:ONE (0)>"
+      expect(SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect).to eq("<SpecNamespace::StructWithSomeEnum some_enum:ONE (0)>")
 
-      SpecNamespace::StructWithEnumMap.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect.should == "<SpecNamespace::StructWithEnumMap my_map:{ONE (0): [TWO (1)]}>"
+      expect(SpecNamespace::StructWithEnumMap.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect).to eq("<SpecNamespace::StructWithEnumMap my_map:{ONE (0): [TWO (1)]}>")
     end
 
     it "should pretty print binary fields" do
-      SpecNamespace::Foo2.new(:my_binary => "\001\002\003").inspect.should == "<SpecNamespace::Foo2 my_binary:010203>"
+      expect(SpecNamespace::Foo2.new(:my_binary => "\001\002\003").inspect).to eq("<SpecNamespace::Foo2 my_binary:010203>")
     end
 
     it "should offer field? methods" do
-      SpecNamespace::Foo.new.opt_string?.should be_false
-      SpecNamespace::Foo.new(:simple => 52).simple?.should be_true
-      SpecNamespace::Foo.new(:my_bool => false).my_bool?.should be_true
-      SpecNamespace::Foo.new(:my_bool => true).my_bool?.should be_true
+      expect(SpecNamespace::Foo.new.opt_string?).to be_falsey
+      expect(SpecNamespace::Foo.new(:simple => 52).simple?).to be_truthy
+      expect(SpecNamespace::Foo.new(:my_bool => false).my_bool?).to be_truthy
+      expect(SpecNamespace::Foo.new(:my_bool => true).my_bool?).to be_truthy
     end
 
     it "should be comparable" do
       s1 = SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::ONE)
       s2 = SpecNamespace::StructWithSomeEnum.new(:some_enum => SpecNamespace::SomeEnum::TWO)
 
-      (s1 <=> s2).should == -1
-      (s2 <=> s1).should == 1
-      (s1 <=> s1).should == 0
-      (s1 <=> SpecNamespace::StructWithSomeEnum.new()).should == -1
+      expect(s1 <=> s2).to eq(-1)
+      expect(s2 <=> s1).to eq(1)
+      expect(s1 <=> s1).to eq(0)
+      expect(s1 <=> SpecNamespace::StructWithSomeEnum.new()).to eq(-1)
     end
 
     it "should read itself off the wire" do
       struct = SpecNamespace::Foo.new
-      prot = Thrift::BaseProtocol.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(
+      prot = Thrift::BaseProtocol.new(double("transport"))
+      expect(prot).to receive(:read_struct_begin).twice
+      expect(prot).to receive(:read_struct_end).twice
+      expect(prot).to receive(:read_field_begin).and_return(
         ['complex', Thrift::Types::MAP, 5], # Foo
         ['words', Thrift::Types::STRING, 2], # Foo
         ['hello', Thrift::Types::STRUCT, 3], # Foo
@@ -112,49 +112,49 @@ describe 'Struct' do
         ['shorts', Thrift::Types::SET, 6], # Foo
         [nil, Thrift::Types::STOP, 0] # Hello
       )
-      prot.should_receive(:read_field_end).exactly(7).times
-      prot.should_receive(:read_map_begin).and_return(
+      expect(prot).to receive(:read_field_end).exactly(7).times
+      expect(prot).to receive(:read_map_begin).and_return(
         [Thrift::Types::I32, Thrift::Types::MAP, 2], # complex
           [Thrift::Types::STRING, Thrift::Types::DOUBLE, 2], # complex/1/value
           [Thrift::Types::STRING, Thrift::Types::DOUBLE, 1] # complex/2/value
       )
-      prot.should_receive(:read_map_end).exactly(3).times
-      prot.should_receive(:read_list_begin).and_return([Thrift::Types::I32, 4])
-      prot.should_receive(:read_list_end)
-      prot.should_receive(:read_set_begin).and_return([Thrift::Types::I16, 2])
-      prot.should_receive(:read_set_end)
-      prot.should_receive(:read_i32).and_return(
+      expect(prot).to receive(:read_map_end).exactly(3).times
+      expect(prot).to receive(:read_list_begin).and_return([Thrift::Types::I32, 4])
+      expect(prot).to receive(:read_list_end)
+      expect(prot).to receive(:read_set_begin).and_return([Thrift::Types::I16, 2])
+      expect(prot).to receive(:read_set_end)
+      expect(prot).to receive(:read_i32).and_return(
         1, 14,        # complex keys
         42,           # simple
         4, 23, 4, 29  # ints
       )
-      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)
+      expect(prot).to receive(:read_string).and_return("pi", "e", "feigenbaum", "apple banana", "what's up?")
+      expect(prot).to receive(:read_double).and_return(Math::PI, Math::E, 4.669201609)
+      expect(prot).to receive(:read_i16).and_return(2, 3)
+      expect(prot).not_to receive(:skip)
       struct.read(prot)
 
-      struct.simple.should == 42
-      struct.complex.should == {1 => {"pi" => Math::PI, "e" => Math::E}, 14 => {"feigenbaum" => 4.669201609}}
-      struct.hello.should == SpecNamespace::Hello.new(:greeting => "what's up?")
-      struct.words.should == "apple banana"
-      struct.ints.should == [4, 23, 4, 29]
-      struct.shorts.should == Set.new([3, 2])
+      expect(struct.simple).to eq(42)
+      expect(struct.complex).to eq({1 => {"pi" => Math::PI, "e" => Math::E}, 14 => {"feigenbaum" => 4.669201609}})
+      expect(struct.hello).to eq(SpecNamespace::Hello.new(:greeting => "what's up?"))
+      expect(struct.words).to eq("apple banana")
+      expect(struct.ints).to eq([4, 23, 4, 29])
+      expect(struct.shorts).to eq(Set.new([3, 2]))
     end
 
     it "should serialize false boolean fields correctly" do
       b = SpecNamespace::BoolStruct.new(:yesno => false)
       prot = Thrift::BinaryProtocol.new(Thrift::MemoryBufferTransport.new)
-      prot.should_receive(:write_bool).with(false)
+      expect(prot).to receive(:write_bool).with(false)
       b.write(prot)
     end
 
     it "should skip unexpected fields in structs and use default values" do
       struct = SpecNamespace::Foo.new
-      prot = Thrift::BaseProtocol.new(mock("transport"))
-      prot.should_receive(:read_struct_begin)
-      prot.should_receive(:read_struct_end)
-      prot.should_receive(:read_field_begin).and_return(
+      prot = Thrift::BaseProtocol.new(double("transport"))
+      expect(prot).to receive(:read_struct_begin)
+      expect(prot).to receive(:read_struct_end)
+      expect(prot).to receive(:read_field_begin).and_return(
         ['simple', Thrift::Types::I32, 1],
         ['complex', Thrift::Types::STRUCT, 5],
         ['thinz', Thrift::Types::MAP, 7],
@@ -162,55 +162,55 @@ describe 'Struct' do
         ['words', Thrift::Types::STRING, 2],
         [nil, Thrift::Types::STOP, 0]
       )
-      prot.should_receive(:read_field_end).exactly(5).times
-      prot.should_receive(:read_i32).and_return(42)
-      prot.should_receive(:read_string).and_return("foobar")
-      prot.should_receive(:skip).with(Thrift::Types::STRUCT)
-      prot.should_receive(:skip).with(Thrift::Types::MAP)
+      expect(prot).to receive(:read_field_end).exactly(5).times
+      expect(prot).to receive(:read_i32).and_return(42)
+      expect(prot).to receive(:read_string).and_return("foobar")
+      expect(prot).to receive(:skip).with(Thrift::Types::STRUCT)
+      expect(prot).to receive(:skip).with(Thrift::Types::MAP)
       # prot.should_receive(:read_map_begin).and_return([Thrift::Types::I32, Thrift::Types::I32, 0])
       # prot.should_receive(:read_map_end)
-      prot.should_receive(:skip).with(Thrift::Types::I32)
+      expect(prot).to receive(:skip).with(Thrift::Types::I32)
       struct.read(prot)
 
-      struct.simple.should == 42
-      struct.complex.should be_nil
-      struct.words.should == "foobar"
-      struct.hello.should == SpecNamespace::Hello.new(:greeting => 'hello, world!')
-      struct.ints.should == [1, 2, 2, 3]
-      struct.shorts.should == Set.new([5, 17, 239])
+      expect(struct.simple).to eq(42)
+      expect(struct.complex).to be_nil
+      expect(struct.words).to eq("foobar")
+      expect(struct.hello).to eq(SpecNamespace::Hello.new(:greeting => 'hello, world!'))
+      expect(struct.ints).to eq([1, 2, 2, 3])
+      expect(struct.shorts).to eq(Set.new([5, 17, 239]))
     end
 
     it "should write itself to the wire" do
-      prot = Thrift::BaseProtocol.new(mock("transport")) #mock("Protocol")
-      prot.should_receive(:write_struct_begin).with("SpecNamespace::Foo")
-      prot.should_receive(:write_struct_begin).with("SpecNamespace::Hello")
-      prot.should_receive(:write_struct_end).twice
-      prot.should_receive(:write_field_begin).with('ints', Thrift::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', Thrift::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', Thrift::Types::SET, 6)
-      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', Thrift::Types::I32, 1)
-      prot.should_receive(:write_i32).with(53)
-      prot.should_receive(:write_field_begin).with('hello', Thrift::Types::STRUCT, 3)
-      prot.should_receive(:write_field_begin).with('greeting', Thrift::Types::STRING, 1)
-      prot.should_receive(:write_string).with('hello, world!')
-      prot.should_receive(:write_map_begin).with(Thrift::Types::I32, Thrift::Types::MAP, 1)
-      prot.should_receive(:write_map_begin).with(Thrift::Types::STRING, Thrift::Types::DOUBLE, 1)
-      prot.should_receive(:write_map_end).twice
-      prot.should_receive(:write_list_begin).with(Thrift::Types::I32, 4)
-      prot.should_receive(:write_list_end)
-      prot.should_receive(:write_set_begin).with(Thrift::Types::I16, 3)
-      prot.should_receive(:write_set_end)
+      prot = Thrift::BaseProtocol.new(double("transport")) #mock("Protocol")
+      expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Foo")
+      expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Hello")
+      expect(prot).to receive(:write_struct_end).twice
+      expect(prot).to receive(:write_field_begin).with('ints', Thrift::Types::LIST, 4)
+      expect(prot).to receive(:write_i32).with(1)
+      expect(prot).to receive(:write_i32).with(2).twice
+      expect(prot).to receive(:write_i32).with(3)
+      expect(prot).to receive(:write_field_begin).with('complex', Thrift::Types::MAP, 5)
+      expect(prot).to receive(:write_i32).with(5)
+      expect(prot).to receive(:write_string).with('foo')
+      expect(prot).to receive(:write_double).with(1.23)
+      expect(prot).to receive(:write_field_begin).with('shorts', Thrift::Types::SET, 6)
+      expect(prot).to receive(:write_i16).with(5)
+      expect(prot).to receive(:write_i16).with(17)
+      expect(prot).to receive(:write_i16).with(239)
+      expect(prot).to receive(:write_field_stop).twice
+      expect(prot).to receive(:write_field_end).exactly(6).times
+      expect(prot).to receive(:write_field_begin).with('simple', Thrift::Types::I32, 1)
+      expect(prot).to receive(:write_i32).with(53)
+      expect(prot).to receive(:write_field_begin).with('hello', Thrift::Types::STRUCT, 3)
+      expect(prot).to receive(:write_field_begin).with('greeting', Thrift::Types::STRING, 1)
+      expect(prot).to receive(:write_string).with('hello, world!')
+      expect(prot).to receive(:write_map_begin).with(Thrift::Types::I32, Thrift::Types::MAP, 1)
+      expect(prot).to receive(:write_map_begin).with(Thrift::Types::STRING, Thrift::Types::DOUBLE, 1)
+      expect(prot).to receive(:write_map_end).twice
+      expect(prot).to receive(:write_list_begin).with(Thrift::Types::I32, 4)
+      expect(prot).to receive(:write_list_end)
+      expect(prot).to receive(:write_set_begin).with(Thrift::Types::I16, 3)
+      expect(prot).to receive(:write_set_end)
 
       struct = SpecNamespace::Foo.new
       struct.words = nil
@@ -221,50 +221,50 @@ describe 'Struct' do
     it "should raise an exception if presented with an unknown container" do
       # yeah this is silly, but I'm going for code coverage here
       struct = SpecNamespace::Foo.new
-      lambda { struct.send :write_container, nil, nil, {:type => "foo"} }.should raise_error(StandardError, "Not a container type: foo")
+      expect { struct.send :write_container, nil, nil, {:type => "foo"} }.to raise_error(StandardError, "Not a container type: foo")
     end
 
     it "should support optional type-checking in Thrift::Struct.new" do
       Thrift.type_checking = true
       begin
-        lambda { SpecNamespace::Hello.new(:greeting => 3) }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Fixnum for field greeting")
+        expect { SpecNamespace::Hello.new(:greeting => 3) }.to raise_error(Thrift::TypeError, /Expected Types::STRING, received (Integer|Fixnum) for field greeting/)
       ensure
         Thrift.type_checking = false
       end
-      lambda { SpecNamespace::Hello.new(:greeting => 3) }.should_not raise_error(Thrift::TypeError)
+      expect { SpecNamespace::Hello.new(:greeting => 3) }.not_to raise_error
     end
 
     it "should support optional type-checking in field accessors" do
       Thrift.type_checking = true
       begin
         hello = SpecNamespace::Hello.new
-        lambda { hello.greeting = 3 }.should raise_error(Thrift::TypeError, "Expected Types::STRING, received Fixnum for field greeting")
+        expect { hello.greeting = 3 }.to raise_error(Thrift::TypeError, /Expected Types::STRING, received (Integer|Fixnum) for field greeting/)
       ensure
         Thrift.type_checking = false
       end
-      lambda { hello.greeting = 3 }.should_not raise_error(Thrift::TypeError)
+      expect { hello.greeting = 3 }.not_to raise_error
     end
 
     it "should raise an exception when unknown types are given to Thrift::Struct.new" do
-      lambda { SpecNamespace::Hello.new(:fish => 'salmon') }.should raise_error(Exception, "Unknown key given to SpecNamespace::Hello.new: fish")
+      expect { SpecNamespace::Hello.new(:fish => 'salmon') }.to raise_error(Exception, "Unknown key given to SpecNamespace::Hello.new: fish")
     end
 
     it "should support `raise Xception, 'message'` for Exception structs" do
       begin
         raise SpecNamespace::Xception, "something happened"
       rescue Thrift::Exception => e
-        e.message.should == "something happened"
-        e.code.should == 1
+        expect(e.message).to eq("something happened")
+        expect(e.code).to eq(1)
         # ensure it gets serialized properly, this is the really important part
-        prot = Thrift::BaseProtocol.new(mock("trans"))
-        prot.should_receive(:write_struct_begin).with("SpecNamespace::Xception")
-        prot.should_receive(:write_struct_end)
-        prot.should_receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)#, "something happened")
-        prot.should_receive(:write_string).with("something happened")
-        prot.should_receive(:write_field_begin).with('code', Thrift::Types::I32, 2)#, 1)
-        prot.should_receive(:write_i32).with(1)
-        prot.should_receive(:write_field_stop)
-        prot.should_receive(:write_field_end).twice
+        prot = Thrift::BaseProtocol.new(double("trans"))
+        expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Xception")
+        expect(prot).to receive(:write_struct_end)
+        expect(prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)#, "something happened")
+        expect(prot).to receive(:write_string).with("something happened")
+        expect(prot).to receive(:write_field_begin).with('code', Thrift::Types::I32, 2)#, 1)
+        expect(prot).to receive(:write_i32).with(1)
+        expect(prot).to receive(:write_field_stop)
+        expect(prot).to receive(:write_field_end).twice
 
         e.write(prot)
       end
@@ -274,17 +274,17 @@ describe 'Struct' do
       begin
         raise SpecNamespace::Xception, :message => "something happened", :code => 5
       rescue Thrift::Exception => e
-        e.message.should == "something happened"
-        e.code.should == 5
-        prot = Thrift::BaseProtocol.new(mock("trans"))
-        prot.should_receive(:write_struct_begin).with("SpecNamespace::Xception")
-        prot.should_receive(:write_struct_end)
-        prot.should_receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)
-        prot.should_receive(:write_string).with("something happened")
-        prot.should_receive(:write_field_begin).with('code', Thrift::Types::I32, 2)
-        prot.should_receive(:write_i32).with(5)
-        prot.should_receive(:write_field_stop)
-        prot.should_receive(:write_field_end).twice
+        expect(e.message).to eq("something happened")
+        expect(e.code).to eq(5)
+        prot = Thrift::BaseProtocol.new(double("trans"))
+        expect(prot).to receive(:write_struct_begin).with("SpecNamespace::Xception")
+        expect(prot).to receive(:write_struct_end)
+        expect(prot).to receive(:write_field_begin).with('message', Thrift::Types::STRING, 1)
+        expect(prot).to receive(:write_string).with("something happened")
+        expect(prot).to receive(:write_field_begin).with('code', Thrift::Types::I32, 2)
+        expect(prot).to receive(:write_i32).with(5)
+        expect(prot).to receive(:write_field_stop)
+        expect(prot).to receive(:write_field_end).twice
 
         e.write(prot)
       end