thrift 0.9.2.0 → 0.14.0

data/spec/thin_http_server_spec.rb

@@ -23,24 +23,24 @@ require 'thrift/server/thin_http_server'
 
 describe Thrift::ThinHTTPServer do
 
-  let(:processor) { mock('processor') }
+  let(:processor) { double('processor') }
 
   describe "#initialize" do
 
     context "when using the defaults" do
 
       it "binds to port 80, with host 0.0.0.0, a path of '/'" do
-        Thin::Server.should_receive(:new).with('0.0.0.0', 80, an_instance_of(Rack::Builder))
+        expect(Thin::Server).to receive(:new).with('0.0.0.0', 80, an_instance_of(Rack::Builder))
         Thrift::ThinHTTPServer.new(processor)
       end
 
       it 'creates a ThinHTTPServer::RackApplicationContext' do
-        Thrift::ThinHTTPServer::RackApplication.should_receive(:for).with("/", processor, an_instance_of(Thrift::BinaryProtocolFactory)).and_return(anything)
+        expect(Thrift::ThinHTTPServer::RackApplication).to receive(:for).with("/", processor, an_instance_of(Thrift::BinaryProtocolFactory)).and_return(anything)
         Thrift::ThinHTTPServer.new(processor)
       end
 
       it "uses the BinaryProtocolFactory" do
-        Thrift::BinaryProtocolFactory.should_receive(:new)
+        expect(Thrift::BinaryProtocolFactory).to receive(:new)
         Thrift::ThinHTTPServer.new(processor)
       end
 
@@ -52,7 +52,7 @@ describe Thrift::ThinHTTPServer do
         ip = "192.168.0.1"
         port = 3000
         path = "/thin"
-        Thin::Server.should_receive(:new).with(ip, port, an_instance_of(Rack::Builder))
+        expect(Thin::Server).to receive(:new).with(ip, port, an_instance_of(Rack::Builder))
         Thrift::ThinHTTPServer.new(processor,
                            :ip => ip,
                            :port => port,
@@ -60,7 +60,7 @@ describe Thrift::ThinHTTPServer do
       end
 
       it 'creates a ThinHTTPServer::RackApplicationContext with a different protocol factory' do
-        Thrift::ThinHTTPServer::RackApplication.should_receive(:for).with("/", processor, an_instance_of(Thrift::JsonProtocolFactory)).and_return(anything)
+        expect(Thrift::ThinHTTPServer::RackApplication).to receive(:for).with("/", processor, an_instance_of(Thrift::JsonProtocolFactory)).and_return(anything)
         Thrift::ThinHTTPServer.new(processor,
                            :protocol_factory => Thrift::JsonProtocolFactory.new)
       end
@@ -72,12 +72,12 @@ describe Thrift::ThinHTTPServer do
   describe "#serve" do
 
     it 'starts the Thin server' do
-      underlying_thin_server = mock('thin server', :start => true)
-      Thin::Server.stub(:new).and_return(underlying_thin_server)
+      underlying_thin_server = double('thin server', :start => true)
+      allow(Thin::Server).to receive(:new).and_return(underlying_thin_server)
 
       thin_thrift_server = Thrift::ThinHTTPServer.new(processor)
 
-      underlying_thin_server.should_receive(:start)
+      expect(underlying_thin_server).to receive(:start)
       thin_thrift_server.serve
     end
   end
@@ -87,8 +87,8 @@ end
 describe Thrift::ThinHTTPServer::RackApplication do
   include Rack::Test::Methods
 
-  let(:processor) { mock('processor') }
-  let(:protocol_factory) { mock('protocol factory') }
+  let(:processor) { double('processor') }
+  let(:protocol_factory) { double('protocol factory') }
 
   def app
     Thrift::ThinHTTPServer::RackApplication.for("/", processor, protocol_factory)
@@ -99,13 +99,13 @@ describe Thrift::ThinHTTPServer::RackApplication do
     it 'receives a non-POST' do
       header('Content-Type', "application/x-thrift")
       get "/"
-      last_response.status.should be 404
+      expect(last_response.status).to be 404
     end
 
     it 'receives a header other than application/x-thrift' do
       header('Content-Type', "application/json")
       post "/"
-      last_response.status.should be 404
+      expect(last_response.status).to be 404
     end
 
   end
@@ -113,26 +113,26 @@ describe Thrift::ThinHTTPServer::RackApplication do
   context "200 response" do
 
     before do
-      protocol_factory.stub(:get_protocol)
-      processor.stub(:process)
+      allow(protocol_factory).to receive(:get_protocol)
+      allow(processor).to receive(:process)
     end
 
     it 'creates an IOStreamTransport' do
       header('Content-Type', "application/x-thrift")
-      Thrift::IOStreamTransport.should_receive(:new).with(an_instance_of(Rack::Lint::InputWrapper), an_instance_of(Rack::Response))
+      expect(Thrift::IOStreamTransport).to receive(:new).with(an_instance_of(Rack::Lint::InputWrapper), an_instance_of(Rack::Response))
       post "/"
     end
 
     it 'fetches the right protocol based on the Transport' do
       header('Content-Type', "application/x-thrift")
-      protocol_factory.should_receive(:get_protocol).with(an_instance_of(Thrift::IOStreamTransport))
+      expect(protocol_factory).to receive(:get_protocol).with(an_instance_of(Thrift::IOStreamTransport))
       post "/"
     end
 
     it 'status code 200' do
       header('Content-Type', "application/x-thrift")
       post "/"
-      last_response.ok?.should be_true
+      expect(last_response.ok?).to be_truthy
     end
 
   end

data/spec/types_spec.rb

@@ -31,85 +31,88 @@ describe Thrift::Types do
 
   context 'type checking' do
     it "should return the proper name for each type" do
-      Thrift.type_name(Thrift::Types::I16).should == "Types::I16"
-      Thrift.type_name(Thrift::Types::VOID).should == "Types::VOID"
-      Thrift.type_name(Thrift::Types::LIST).should == "Types::LIST"
-      Thrift.type_name(42).should be_nil
+      expect(Thrift.type_name(Thrift::Types::I16)).to eq("Types::I16")
+      expect(Thrift.type_name(Thrift::Types::VOID)).to eq("Types::VOID")
+      expect(Thrift.type_name(Thrift::Types::LIST)).to eq("Types::LIST")
+      expect(Thrift.type_name(42)).to be_nil
     end
 
     it "should check types properly" do
       # lambda { Thrift.check_type(nil, Thrift::Types::STOP) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(3,              {:type => Thrift::Types::STOP},   :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil,            {:type => Thrift::Types::VOID},   :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(3,              {:type => Thrift::Types::VOID},   :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(true,           {:type => Thrift::Types::BOOL},   :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(3,              {:type => Thrift::Types::BOOL},   :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(42,             {:type => Thrift::Types::BYTE},   :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(42,             {:type => Thrift::Types::I16},    :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(42,             {:type => Thrift::Types::I32},    :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(42,             {:type => Thrift::Types::I64},    :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(3.14,           {:type => Thrift::Types::I32},    :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(3.14,           {:type => Thrift::Types::DOUBLE}, :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(3,              {:type => Thrift::Types::DOUBLE}, :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type("3",            {:type => Thrift::Types::STRING}, :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(3,              {:type => Thrift::Types::STRING}, :foo) }.should raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(3,              {:type => Thrift::Types::STOP},   :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil,            {:type => Thrift::Types::VOID},   :foo) }.not_to raise_error
+      expect { Thrift.check_type(3,              {:type => Thrift::Types::VOID},   :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(true,           {:type => Thrift::Types::BOOL},   :foo) }.not_to raise_error
+      expect { Thrift.check_type(3,              {:type => Thrift::Types::BOOL},   :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(42,             {:type => Thrift::Types::BYTE},   :foo) }.not_to raise_error
+      expect { Thrift.check_type(42,             {:type => Thrift::Types::I16},    :foo) }.not_to raise_error
+      expect { Thrift.check_type(42,             {:type => Thrift::Types::I32},    :foo) }.not_to raise_error
+      expect { Thrift.check_type(42,             {:type => Thrift::Types::I64},    :foo) }.not_to raise_error
+      expect { Thrift.check_type(3.14,           {:type => Thrift::Types::I32},    :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(3.14,           {:type => Thrift::Types::DOUBLE}, :foo) }.not_to raise_error
+      expect { Thrift.check_type(3,              {:type => Thrift::Types::DOUBLE}, :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type("3",            {:type => Thrift::Types::STRING}, :foo) }.not_to raise_error
+      expect { Thrift.check_type(3,              {:type => Thrift::Types::STRING}, :foo) }.to raise_error(Thrift::TypeError)
       hello = SpecNamespace::Hello.new
-      lambda { Thrift.check_type(hello,          {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}, :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type("foo",          {:type => Thrift::Types::STRUCT}, :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type({:foo => 1},    {:type => Thrift::Types::MAP},    :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type([1],            {:type => Thrift::Types::MAP},    :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type([1],            {:type => Thrift::Types::LIST},   :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type({:foo => 1},    {:type => Thrift::Types::LIST},   :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(Set.new([1,2]), {:type => Thrift::Types::SET},    :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type([1,2],          {:type => Thrift::Types::SET},    :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type({:foo => true}, {:type => Thrift::Types::SET},    :foo) }.should raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(hello,          {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}, :foo) }.not_to raise_error
+      expect { Thrift.check_type("foo",          {:type => Thrift::Types::STRUCT}, :foo) }.to raise_error(Thrift::TypeError)
+      field = {:type => Thrift::Types::MAP, :key => {:type => Thrift::Types::I32}, :value => {:type => Thrift::Types::STRING}}
+      expect { Thrift.check_type({1 => "one"},   field,                            :foo) }.not_to raise_error
+      expect { Thrift.check_type([1],            field,                            :foo) }.to raise_error(Thrift::TypeError)
+      field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::I32}}
+      expect { Thrift.check_type([1],            field,                            :foo) }.not_to raise_error
+      expect { Thrift.check_type({:foo => 1},    field,                            :foo) }.to raise_error(Thrift::TypeError)
+      field = {:type => Thrift::Types::SET, :element => {:type => Thrift::Types::I32}}
+      expect { Thrift.check_type(Set.new([1,2]), field,                            :foo) }.not_to raise_error
+      expect { Thrift.check_type([1,2],          field,                            :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type({:foo => true}, field,                            :foo) }.to raise_error(Thrift::TypeError)
     end
 
     it "should error out if nil is passed and skip_types is false" do
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::BOOL},   :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::BYTE},   :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::I16},    :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::I32},    :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::I64},    :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::DOUBLE}, :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::STRING}, :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::STRUCT}, :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::LIST},   :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::SET},    :foo, false) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(nil, {:type => Thrift::Types::MAP},    :foo, false) }.should raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::BOOL},   :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::BYTE},   :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::I16},    :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::I32},    :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::I64},    :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::DOUBLE}, :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::STRING}, :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::STRUCT}, :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::LIST},   :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::SET},    :foo, false) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(nil, {:type => Thrift::Types::MAP},    :foo, false) }.to raise_error(Thrift::TypeError)
     end
 
     it "should check element types on containers" do
       field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::I32}}
-      lambda { Thrift.check_type([1, 2], field, :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type([1, nil, 2], field, :foo) }.should raise_error(Thrift::TypeError)
+      expect { Thrift.check_type([1, 2], field, :foo) }.not_to raise_error
+      expect { Thrift.check_type([1, nil, 2], field, :foo) }.to raise_error(Thrift::TypeError)
       field = {:type => Thrift::Types::MAP, :key => {:type => Thrift::Types::I32}, :value => {:type => Thrift::Types::STRING}}
-      lambda { Thrift.check_type({1 => "one", 2 => "two"}, field, :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type({1 => "one", nil => "nil"}, field, :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type({1 => nil, 2 => "two"}, field, :foo) }.should raise_error(Thrift::TypeError)
+      expect { Thrift.check_type({1 => "one", 2 => "two"}, field, :foo) }.not_to raise_error
+      expect { Thrift.check_type({1 => "one", nil => "nil"}, field, :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type({1 => nil, 2 => "two"}, field, :foo) }.to raise_error(Thrift::TypeError)
       field = {:type => Thrift::Types::SET, :element => {:type => Thrift::Types::I32}}
-      lambda { Thrift.check_type(Set.new([1, 2]), field, :foo) }.should_not raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(Set.new([1, nil, 2]), field, :foo) }.should raise_error(Thrift::TypeError)
-      lambda { Thrift.check_type(Set.new([1, 2.3, 2]), field, :foo) }.should raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(Set.new([1, 2]), field, :foo) }.not_to raise_error
+      expect { Thrift.check_type(Set.new([1, nil, 2]), field, :foo) }.to raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(Set.new([1, 2.3, 2]), field, :foo) }.to raise_error(Thrift::TypeError)
 
       field = {:type => Thrift::Types::STRUCT, :class => SpecNamespace::Hello}
-      lambda { Thrift.check_type(SpecNamespace::BoolStruct, field, :foo) }.should raise_error(Thrift::TypeError)
+      expect { Thrift.check_type(SpecNamespace::BoolStruct, field, :foo) }.to raise_error(Thrift::TypeError)
     end
 
     it "should give the Thrift::TypeError a readable message" do
-      msg = "Expected Types::STRING, received Fixnum for field foo"
-      lambda { Thrift.check_type(3, {:type => Thrift::Types::STRING}, :foo) }.should raise_error(Thrift::TypeError, msg)
-      msg = "Expected Types::STRING, received Fixnum for field foo.element"
+      msg = /Expected Types::STRING, received (Integer|Fixnum) for field foo/
+      expect { Thrift.check_type(3, {:type => Thrift::Types::STRING}, :foo) }.to raise_error(Thrift::TypeError, msg)
+      msg = /Expected Types::STRING, received (Integer|Fixnum) for field foo.element/
       field = {:type => Thrift::Types::LIST, :element => {:type => Thrift::Types::STRING}}
-      lambda { Thrift.check_type([3], field, :foo) }.should raise_error(Thrift::TypeError, msg)
+      expect { Thrift.check_type([3], field, :foo) }.to raise_error(Thrift::TypeError, msg)
       msg = "Expected Types::I32, received NilClass for field foo.element.key"
       field = {:type => Thrift::Types::LIST,
                :element => {:type => Thrift::Types::MAP,
                             :key => {:type => Thrift::Types::I32},
                             :value => {:type => Thrift::Types::I32}}}
-      lambda { Thrift.check_type([{nil => 3}], field, :foo) }.should raise_error(Thrift::TypeError, msg)
+      expect { Thrift.check_type([{nil => 3}], field, :foo) }.to raise_error(Thrift::TypeError, msg)
       msg = "Expected Types::I32, received NilClass for field foo.element.value"
-      lambda { Thrift.check_type([{1 => nil}], field, :foo) }.should raise_error(Thrift::TypeError, msg)
+      expect { Thrift.check_type([{1 => nil}], field, :foo) }.to raise_error(Thrift::TypeError, msg)
     end
   end
 end

data/spec/union_spec.rb

@@ -24,73 +24,84 @@ describe 'Union' do
   describe Thrift::Union do
     it "should return nil value in unset union" do
       union = SpecNamespace::My_union.new
-      union.get_set_field.should == nil
-      union.get_value.should == nil
+      expect(union.get_set_field).to eq(nil)
+      expect(union.get_value).to eq(nil)
     end
 
     it "should set a field and be accessible through get_value and the named field accessor" do
       union = SpecNamespace::My_union.new
       union.integer32 = 25
-      union.get_set_field.should == :integer32
-      union.get_value.should == 25
-      union.integer32.should == 25
+      expect(union.get_set_field).to eq(:integer32)
+      expect(union.get_value).to eq(25)
+      expect(union.integer32).to eq(25)
     end
 
     it "should work correctly when instantiated with static field constructors" do
       union = SpecNamespace::My_union.integer32(5)
-      union.get_set_field.should == :integer32
-      union.integer32.should == 5
+      expect(union.get_set_field).to eq(:integer32)
+      expect(union.integer32).to eq(5)
     end
 
     it "should raise for wrong set field" do
       union = SpecNamespace::My_union.new
       union.integer32 = 25
-      lambda { union.some_characters }.should raise_error(RuntimeError, "some_characters is not union's set field.")
+      expect { union.some_characters }.to raise_error(RuntimeError, "some_characters is not union's set field.")
+    end
+
+    it "should raise for wrong set field when hash initialized and type checking is off" do
+      Thrift.type_checking = false
+      union = SpecNamespace::My_union.new({incorrect_field: :incorrect})
+      expect { Thrift::Serializer.new.serialize(union) }.to raise_error(RuntimeError, "set_field is not valid for this union!")
     end
 
     it "should not be equal to nil" do
       union = SpecNamespace::My_union.new
-      union.should_not == nil
+      expect(union).not_to eq(nil)
+    end
+
+    it "should not be equal with an empty String" do
+      union = SpecNamespace::My_union.new
+      expect(union).not_to eq('')
     end
 
     it "should not equate two different unions, i32 vs. string" do
       union = SpecNamespace::My_union.new(:integer32, 25)
       other_union = SpecNamespace::My_union.new(:some_characters, "blah!")
-      union.should_not == other_union
+      expect(union).not_to eq(other_union)
     end
 
     it "should properly reset setfield and setvalue" do
       union = SpecNamespace::My_union.new(:integer32, 25)
-      union.get_set_field.should == :integer32
+      expect(union.get_set_field).to eq(:integer32)
       union.some_characters = "blah!"
-      union.get_set_field.should == :some_characters
-      union.get_value.should == "blah!"
-      lambda { union.integer32 }.should raise_error(RuntimeError, "integer32 is not union's set field.")
+      expect(union.get_set_field).to eq(:some_characters)
+      expect(union.get_value).to eq("blah!")
+      expect { union.integer32 }.to raise_error(RuntimeError, "integer32 is not union's set field.")
     end
 
     it "should not equate two different unions with different values" do
       union = SpecNamespace::My_union.new(:integer32, 25)
       other_union = SpecNamespace::My_union.new(:integer32, 400)
-      union.should_not == other_union
+      expect(union).not_to eq(other_union)
     end
 
     it "should not equate two different unions with different fields" do
       union = SpecNamespace::My_union.new(:integer32, 25)
       other_union = SpecNamespace::My_union.new(:other_i32, 25)
-      union.should_not == other_union
+      expect(union).not_to eq(other_union)
     end
 
     it "should inspect properly" do
       union = SpecNamespace::My_union.new(:integer32, 25)
-      union.inspect.should == "<SpecNamespace::My_union integer32: 25>"
+      expect(union.inspect).to eq("<SpecNamespace::My_union integer32: 25>")
     end
 
     it "should not allow setting with instance_variable_set" do
       union = SpecNamespace::My_union.new(:integer32, 27)
       union.instance_variable_set(:@some_characters, "hallo!")
-      union.get_set_field.should == :integer32
-      union.get_value.should == 27
-      lambda { union.some_characters }.should raise_error(RuntimeError, "some_characters is not union's set field.")
+      expect(union.get_set_field).to eq(:integer32)
+      expect(union.get_value).to eq(27)
+      expect { union.some_characters }.to raise_error(RuntimeError, "some_characters is not union's set field.")
     end
 
     it "should serialize to binary correctly" do
@@ -102,7 +113,7 @@ describe 'Union' do
 
       other_union = SpecNamespace::My_union.new(:integer32, 25)
       other_union.read(proto)
-      other_union.should == union
+      expect(other_union).to eq(union)
     end
 
     it "should serialize to json correctly" do
@@ -114,24 +125,24 @@ describe 'Union' do
 
       other_union = SpecNamespace::My_union.new(:integer32, 25)
       other_union.read(proto)
-      other_union.should == union
+      expect(other_union).to eq(union)
     end
 
     it "should raise when validating unset union" do
       union = SpecNamespace::My_union.new
-      lambda { union.validate }.should raise_error(StandardError, "Union fields are not set.")
+      expect { union.validate }.to raise_error(StandardError, "Union fields are not set.")
 
       other_union = SpecNamespace::My_union.new(:integer32, 1)
-      lambda { other_union.validate }.should_not raise_error(StandardError, "Union fields are not set.")
+      expect { other_union.validate }.not_to raise_error
     end
 
     it "should validate an enum field properly" do
       union = SpecNamespace::TestUnion.new(:enum_field, 3)
-      union.get_set_field.should == :enum_field
-      lambda { union.validate }.should raise_error(Thrift::ProtocolException, "Invalid value of field enum_field!")
+      expect(union.get_set_field).to eq(:enum_field)
+      expect { union.validate }.to raise_error(Thrift::ProtocolException, "Invalid value of field enum_field!")
 
       other_union = SpecNamespace::TestUnion.new(:enum_field, 1)
-      lambda { other_union.validate }.should_not raise_error(Thrift::ProtocolException, "Invalid value of field enum_field!")
+      expect { other_union.validate }.not_to raise_error
     end
 
     it "should properly serialize and match structs with a union" do
@@ -146,37 +157,37 @@ describe 'Union' do
       other_union = SpecNamespace::My_union.new(:some_characters, "hello there")
       swu2 = SpecNamespace::Struct_with_union.new(:fun_union => other_union)
 
-      swu2.should_not == swu
+      expect(swu2).not_to eq(swu)
 
       swu2.read(proto)
-      swu2.should == swu
+      expect(swu2).to eq(swu)
     end
 
     it "should support old style constructor" do
       union = SpecNamespace::My_union.new(:integer32 => 26)
-      union.get_set_field.should == :integer32
-      union.get_value.should == 26
+      expect(union.get_set_field).to eq(:integer32)
+      expect(union.get_value).to eq(26)
     end
 
     it "should not throw an error when inspected and unset" do
-      lambda{SpecNamespace::TestUnion.new().inspect}.should_not raise_error
+      expect{SpecNamespace::TestUnion.new().inspect}.not_to raise_error
     end
 
     it "should print enum value name when inspected" do
-      SpecNamespace::My_union.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect.should == "<SpecNamespace::My_union some_enum: ONE (0)>"
+      expect(SpecNamespace::My_union.new(:some_enum => SpecNamespace::SomeEnum::ONE).inspect).to eq("<SpecNamespace::My_union some_enum: ONE (0)>")
 
-      SpecNamespace::My_union.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect.should == "<SpecNamespace::My_union my_map: {ONE (0): [TWO (1)]}>"
+      expect(SpecNamespace::My_union.new(:my_map => {SpecNamespace::SomeEnum::ONE => [SpecNamespace::SomeEnum::TWO]}).inspect).to eq("<SpecNamespace::My_union my_map: {ONE (0): [TWO (1)]}>")
     end
 
     it "should offer field? methods" do
-      SpecNamespace::My_union.new.some_enum?.should be_false
-      SpecNamespace::My_union.new(:some_enum => SpecNamespace::SomeEnum::ONE).some_enum?.should be_true
-      SpecNamespace::My_union.new(:im_true => false).im_true?.should be_true
-      SpecNamespace::My_union.new(:im_true => true).im_true?.should be_true
+      expect(SpecNamespace::My_union.new.some_enum?).to be_falsey
+      expect(SpecNamespace::My_union.new(:some_enum => SpecNamespace::SomeEnum::ONE).some_enum?).to be_truthy
+      expect(SpecNamespace::My_union.new(:im_true => false).im_true?).to be_truthy
+      expect(SpecNamespace::My_union.new(:im_true => true).im_true?).to be_truthy
     end
 
     it "should pretty print binary fields" do
-      SpecNamespace::TestUnion.new(:binary_field => "\001\002\003").inspect.should == "<SpecNamespace::TestUnion binary_field: 010203>"
+      expect(SpecNamespace::TestUnion.new(:binary_field => "\001\002\003").inspect).to eq("<SpecNamespace::TestUnion binary_field: 010203>")
     end
 
     it "should be comparable" do
@@ -195,7 +206,7 @@ describe 'Union' do
       for y in 0..3
         for x in 0..3
           # puts "#{objs[y].inspect} <=> #{objs[x].inspect} should == #{relationships[y][x]}"
-          (objs[y] <=> objs[x]).should == relationships[y][x]
+          expect(objs[y] <=> objs[x]).to eq(relationships[y][x])
         end
       end
     end