protobuf 3.0.4 → 3.0.5

data/spec/lib/protobuf/logger_spec.rb

@@ -20,22 +20,22 @@ describe Protobuf::Logger do
 
     it 'doesn\'t create a logger if the file was not set' do
       subject.file = nil
-      subject.instance.should be_nil
+      expect(subject.instance).to be_nil
     end
 
     it 'doesn\'t create a logger if the level was not set' do
       subject.level = nil
-      subject.instance.should be_nil
+      expect(subject.instance).to be_nil
     end
 
     it 'gets a new instance of the logger when file and level are set' do
-      subject.file.should_not be_nil
-      subject.level.should_not be_nil
-      subject.instance.should_not be_nil
+      expect(subject.file).to_not be_nil
+      expect(subject.level).to_not be_nil
+      expect(subject.instance).to_not be_nil
     end
 
     it 'keeps the same object from multiple calls to instance' do
-      subject.instance === subject.instance
+      expect(subject.instance).to equal(subject.instance)
     end
 
   end
@@ -43,13 +43,13 @@ describe Protobuf::Logger do
   describe '.configure' do
     before(:each) { subject.reset_device! }
     it 'sets the file and level in one call' do
-      subject.file.should_not be
-      subject.level.should_not be
-      subject.instance.should_not be
+      expect(subject.file).to_not be
+      expect(subject.level).to_not be
+      expect(subject.instance).to_not be
       subject.configure :file => 'myfile.log', :level => ::Logger::WARN
-      subject.file.should == 'myfile.log'
-      subject.level.should == ::Logger::WARN
-      subject.instance.level.should == ::Logger::WARN
+      expect(subject.file).to eq('myfile.log')
+      expect(subject.level).to eq(::Logger::WARN)
+      expect(subject.instance.level).to eq(::Logger::WARN)
     end
 
   end
@@ -57,13 +57,13 @@ describe Protobuf::Logger do
   describe '.reset_device!' do
 
     it 'resets the logger instance, file, and level' do
-      subject.instance.should be
-      subject.file.should be
-      subject.level.should be
+      expect(subject.instance).to be
+      expect(subject.file).to be
+      expect(subject.level).to be
       subject.reset_device!
-      subject.instance.should_not be
-      subject.file.should_not be
-      subject.level.should_not be
+      expect(subject.instance).to_not be
+      expect(subject.file).to_not be
+      expect(subject.level).to_not be
     end
 
   end
@@ -72,7 +72,7 @@ describe Protobuf::Logger do
 
     it 'doesn\'t raise errors when log instance is nil' do
       subject.reset_device!
-      subject.instance.should be_nil
+      expect(subject.instance).to be_nil
       expect {
         subject.debug 'No errors here'
         subject.info 'No errors here'
@@ -85,8 +85,8 @@ describe Protobuf::Logger do
     end
 
     it 'logs correctly when instance is valid' do
-      subject.instance.should_not be_nil
-      subject.instance.should_receive(:info).with('Should log great')
+      expect(subject.instance).to_not be_nil
+      expect(subject.instance).to receive(:info).with('Should log great')
       subject.info 'Should log great'
     end
 
@@ -114,20 +114,20 @@ describe Protobuf::Logger do
 
       context '#log_exception' do
         it 'logs the exception message as an error and backtrace as debug' do
-          subject.should_receive(:log_error).twice
-          subject.should_receive(:log_debug)
+          expect(subject).to receive(:log_error).twice
+          expect(subject).to receive(:log_debug)
           subject.log_exception(RuntimeError.new('this is an exception'))
         end
       end
 
-      its(:log_signature) { should eq "[MyTestClass]" }
+      specify { expect(subject.log_signature).to eq "[MyTestClass]" }
       describe '#sign_message' do
-        specify { subject.sign_message("this is a test").should eq "[MyTestClass] this is a test" }
-        specify { subject.class.sign_message("this is a test").should eq "[MyTestClass] this is a test" }
+        specify { expect(subject.sign_message("this is a test")).to eq "[MyTestClass] this is a test" }
+        specify { expect(subject.class.sign_message("this is a test")).to eq "[MyTestClass] this is a test" }
       end
 
       it 'passes all embedded log calls to Logger instance' do
-        Protobuf::Logger.instance.should_receive(:debug).with('[MyTestClass] log this')
+        expect(Protobuf::Logger.instance).to receive(:debug).with('[MyTestClass] log this')
         subject.log_debug('log this')
       end
 

data/spec/lib/protobuf/message_spec.rb

@@ -6,7 +6,7 @@ describe Protobuf::Message do
     let(:message) { ::Test::Resource.new(:name => "Jim") }
 
     it 'creates a new message object decoded from the given bytes' do
-      ::Test::Resource.decode(message.encode).should eq message
+      expect(::Test::Resource.decode(message.encode)).to eq message
     end
   end
 
@@ -62,41 +62,41 @@ describe Protobuf::Message do
     let(:values) { { :name => "Jim" } }
 
     it 'creates a new message object with the given values and returns the encoded bytes' do
-      ::Test::Resource.encode(values).should eq ::Test::Resource.new(values).encode
+      expect(::Test::Resource.encode(values)).to eq ::Test::Resource.new(values).encode
     end
   end
 
   describe '#initialize' do
     it "initializes the enum getter to 0" do
       test_enum = Test::EnumTestMessage.new
-      test_enum.non_default_enum.should eq(0)
+      expect(test_enum.non_default_enum).to eq(0)
     end
 
     it "exposes the enum getter raw value through ! method" do
       test_enum = Test::EnumTestMessage.new
-      test_enum.non_default_enum!.should be_nil
+      expect(test_enum.non_default_enum!).to be_nil
     end
 
     it "exposes the enum getter raw value through ! method (when set)" do
       test_enum = Test::EnumTestMessage.new
       test_enum.non_default_enum = 1
-      test_enum.non_default_enum!.should eq(1)
+      expect(test_enum.non_default_enum!).to eq(1)
     end
 
     it "does not try to set attributes which have nil values" do
-      Test::EnumTestMessage.any_instance.should_not_receive("non_default_enum=")
+      expect_any_instance_of(Test::EnumTestMessage).not_to receive("non_default_enum=")
       Test::EnumTestMessage.new(:non_default_enum => nil)
     end
 
     it "takes a hash as an initialization argument" do
       test_enum = Test::EnumTestMessage.new(:non_default_enum => 2)
-      test_enum.non_default_enum.should eq(2)
+      expect(test_enum.non_default_enum).to eq(2)
     end
 
     it "initializes with an object that responds to #to_hash" do
       hashie_object = OpenStruct.new(:to_hash => { :non_default_enum => 2 })
       test_enum = Test::EnumTestMessage.new(hashie_object)
-      test_enum.non_default_enum.should eq(2)
+      expect(test_enum.non_default_enum).to eq(2)
     end
   end
 
@@ -114,7 +114,7 @@ describe Protobuf::Message do
 
         message = ::Test::Resource.new(:name => name)
         new_message = ::Test::Resource.decode(message.encode)
-        (new_message.name == name).should be_true
+        expect(new_message.name == name).to be_truthy
       end
 
       it "trims binary when binary is input for string fields" do
@@ -123,7 +123,7 @@ describe Protobuf::Message do
 
         message = ::Test::Resource.new(:name => name)
         new_message = ::Test::Resource.decode(message.encode)
-        (new_message.name == "my name").should be_true
+        expect(new_message.name == "my name").to be_truthy
       end
     end
 
@@ -149,19 +149,19 @@ describe Protobuf::Message do
 
       it "sets the value to nil when empty array is passed" do
         message.repeated_enum = []
-        message.instance_variable_get("@values")[:repeated_enum].should be_nil
+        expect(message.instance_variable_get("@values")[:repeated_enum]).to be_nil
       end
 
       it "does not compact the edit original array" do
         a = [nil].freeze
         message.repeated_enum = a
-        message.repeated_enum.should eq([])
-        a.should eq([nil].freeze)
+        expect(message.repeated_enum).to eq([])
+        expect(a).to eq([nil].freeze)
       end
 
       it "compacts the set array" do
         message.repeated_enum = [nil]
-        message.repeated_enum.should eq([])
+        expect(message.repeated_enum).to eq([])
       end
 
       it "raises TypeError when a non-array replaces it" do
@@ -179,16 +179,16 @@ describe Protobuf::Message do
 
     it "sets the predicate to true when the boolean value is true" do
       subject.active = true
-      subject.active?.should be_true
+      expect(subject.active?).to be_truthy
     end
 
     it "sets the predicate to false when the boolean value is false" do
       subject.active = false
-      subject.active?.should be_false
+      expect(subject.active?).to be_falsey
     end
 
     it "does not put predicate methods on non-boolean fields" do
-      Test::ResourceFindRequest.new(:name => "resource").should_not respond_to(:name?)
+      expect(Test::ResourceFindRequest.new(:name => "resource")).to_not respond_to(:name?)
     end
   end
 
@@ -196,11 +196,11 @@ describe Protobuf::Message do
     subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
 
     it "is false when the message does not have the field" do
-      subject.respond_to_and_has?(:other_field).should be_false
+      expect(subject.respond_to_and_has?(:other_field)).to be_falsey
     end
 
     it "is true when the message has the field" do
-      subject.respond_to_and_has?(:non_default_enum).should be_true
+      expect(subject.respond_to_and_has?(:non_default_enum)).to be_truthy
     end
   end
 
@@ -208,38 +208,38 @@ describe Protobuf::Message do
     subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
 
     it "is false when the message does not have the field" do
-      subject.respond_to_and_has_and_present?(:other_field).should be_false
+      expect(subject.respond_to_and_has_and_present?(:other_field)).to be_falsey
     end
 
     it "is false when the field is repeated and a value is not present" do
-      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+      expect(subject.respond_to_and_has_and_present?(:repeated_enums)).to be_falsey
     end
 
     it "is false when the field is repeated and the value is empty array" do
       subject.repeated_enums = []
-      subject.respond_to_and_has_and_present?(:repeated_enums).should be_false
+      expect(subject.respond_to_and_has_and_present?(:repeated_enums)).to be_falsey
     end
 
     it "is true when the field is repeated and a value is present" do
       subject.repeated_enums = [2]
-      subject.respond_to_and_has_and_present?(:repeated_enums).should be_true
+      expect(subject.respond_to_and_has_and_present?(:repeated_enums)).to be_truthy
     end
 
     it "is true when the message has the field" do
-      subject.respond_to_and_has_and_present?(:non_default_enum).should be_true
+      expect(subject.respond_to_and_has_and_present?(:non_default_enum)).to be_truthy
     end
 
     context "#API" do
       subject { Test::EnumTestMessage.new(:non_default_enum => 2) }
 
-      it { should respond_to(:respond_to_and_has_and_present?) }
-      it { should respond_to(:responds_to_and_has_and_present?) }
-      it { should respond_to(:responds_to_has?) }
-      it { should respond_to(:respond_to_has?) }
-      it { should respond_to(:respond_to_has_present?) }
-      it { should respond_to(:responds_to_has_present?) }
-      it { should respond_to(:respond_to_and_has_present?) }
-      it { should respond_to(:responds_to_and_has_present?) }
+      specify { expect(subject).to respond_to(:respond_to_and_has_and_present?) }
+      specify { expect(subject).to respond_to(:responds_to_and_has_and_present?) }
+      specify { expect(subject).to respond_to(:responds_to_has?) }
+      specify { expect(subject).to respond_to(:respond_to_has?) }
+      specify { expect(subject).to respond_to(:respond_to_has_present?) }
+      specify { expect(subject).to respond_to(:responds_to_has_present?) }
+      specify { expect(subject).to respond_to(:respond_to_and_has_present?) }
+      specify { expect(subject).to respond_to(:responds_to_and_has_present?) }
     end
 
   end
@@ -248,24 +248,24 @@ describe Protobuf::Message do
     context 'generating values for an ENUM field' do
       it 'converts the enum to its tag representation' do
         hash = Test::EnumTestMessage.new(:non_default_enum => :TWO).to_hash
-        hash.should eq({ :non_default_enum => 2 })
+        expect(hash).to eq({ :non_default_enum => 2 })
       end
 
       it 'does not populate default values' do
         hash = Test::EnumTestMessage.new.to_hash
-        hash.should eq(Hash.new)
+        expect(hash).to eq(Hash.new)
       end
 
       it 'converts repeated enum fields to an array of the tags' do
         hash = Test::EnumTestMessage.new(:repeated_enums => [ :ONE, :TWO, :TWO, :ONE ]).to_hash
-        hash.should eq({ :repeated_enums => [ 1, 2, 2, 1 ] })
+        expect(hash).to eq({ :repeated_enums => [ 1, 2, 2, 1 ] })
       end
     end
 
     context 'generating values for a Message field' do
       it 'recursively hashes field messages' do
         hash = Test::Nested.new({ :resource => { :name => 'Nested' } }).to_hash
-        hash.should eq({ :resource => { :name => 'Nested' } })
+        expect(hash).to eq({ :resource => { :name => 'Nested' } })
       end
 
       it 'recursively hashes a repeated set of messages' do
@@ -274,7 +274,7 @@ describe Protobuf::Message do
           Test::Resource.new(:name => 'Resource 2')
         ])
 
-        proto.to_hash.should eq({ :multiple_resources => [ { :name => 'Resource 1' },
+        expect(proto.to_hash).to eq({ :multiple_resources => [ { :name => 'Resource 1' },
                                                            { :name => 'Resource 2' } ] })
 
       end
@@ -286,7 +286,7 @@ describe Protobuf::Message do
       ::Test::ResourceFindRequest.new({ :name => 'Test Name', :active => false })
     end
 
-    its(:to_json) { should eq '{"name":"Test Name","active":false}' }
+    specify { expect(subject.to_json).to eq '{"name":"Test Name","active":false}' }
   end
 
   describe '.to_json' do
@@ -330,8 +330,8 @@ describe Protobuf::Message do
     end
 
     it 'returns nil when field is not found' do
-      ::Test::Resource.get_extension_field(-1).should be_nil
-      ::Test::Resource.get_extension_field(nil).should be_nil
+      expect(::Test::Resource.get_extension_field(-1)).to be_nil
+      expect(::Test::Resource.get_extension_field(nil)).to be_nil
     end
   end
 
@@ -360,8 +360,8 @@ describe Protobuf::Message do
     end
 
     it 'returns nil when field is not defined' do
-      ::Test::Resource.get_field(-1).should be_nil
-      ::Test::Resource.get_field(nil).should be_nil
+      expect(::Test::Resource.get_field(-1)).to be_nil
+      expect(::Test::Resource.get_field(nil)).to be_nil
     end
   end
 

data/spec/lib/protobuf/optionable_spec.rb

@@ -20,7 +20,7 @@ describe 'Optionable' do
 
     it 'defaults the value to true' do
       OptionableSetOptionTest.set_option(:baz_enabled)
-      expect(OptionableSetOptionTest.get_option(:baz_enabled)).to be_true
+      expect(OptionableSetOptionTest.get_option(:baz_enabled)).to be_truthy
     end
   end
 

data/spec/lib/protobuf/rpc/client_spec.rb

@@ -10,29 +10,29 @@ describe Protobuf::Rpc::Client do
     before { reset_service_location(Test::ResourceService) }
 
     it 'should be able to get a client through the Service#client helper method' do
-      Test::ResourceService.client(:port => 9191).should eq(Protobuf::Rpc::Client.new(:service => Test::ResourceService, :port => 9191))
+      expect(::Test::ResourceService.client(:port => 9191)).to eq(Protobuf::Rpc::Client.new(:service => Test::ResourceService, :port => 9191))
     end
 
     it "should be able to override a service location's host and port" do
       Test::ResourceService.located_at 'somewheregreat.com:12345'
       clean_client = Test::ResourceService.client
-      clean_client.options[:host].should eq('somewheregreat.com')
-      clean_client.options[:port].should eq(12345)
+      expect(clean_client.options[:host]).to eq('somewheregreat.com')
+      expect(clean_client.options[:port]).to eq(12345)
 
       updated_client = Test::ResourceService.client(:host => 'amazing.com', :port => 54321)
-      updated_client.options[:host].should eq('amazing.com')
-      updated_client.options[:port].should eq(54321)
+      expect(updated_client.options[:host]).to eq('amazing.com')
+      expect(updated_client.options[:port]).to eq(54321)
     end
 
     it 'should be able to define which service to create itself for' do
       client = Protobuf::Rpc::Client.new :service => Test::ResourceService
-      client.options[:service].should eq(Test::ResourceService)
+      expect(client.options[:service]).to eq(Test::ResourceService)
     end
 
     it 'should have a hard default for host and port on a service that has not been configured' do
       client = Test::ResourceService.client
-      client.options[:host].should eq(Protobuf::Rpc::Service::DEFAULT_HOST)
-      client.options[:port].should eq(Protobuf::Rpc::Service::DEFAULT_PORT)
+      expect(client.options[:host]).to eq(Protobuf::Rpc::Service::DEFAULT_HOST)
+      expect(client.options[:port]).to eq(Protobuf::Rpc::Service::DEFAULT_PORT)
     end
 
   end
@@ -45,7 +45,7 @@ describe Protobuf::Rpc::Client do
 
     it 'should respond to defined service methods' do
       client = Test::ResourceService.client
-      client.should_receive(:send_request).and_return(nil)
+      expect(client).to receive(:send_request).and_return(nil)
       expect { client.find(nil) }.to_not raise_error
     end
   end
@@ -54,11 +54,11 @@ describe Protobuf::Rpc::Client do
 
     it 'should be able to create the correct request object if passed a hash' do
       client = Test::ResourceService.client
-      client.should_receive(:send_request)
+      expect(client).to receive(:send_request)
       client.find({:name => 'Test Name', :active => false})
-      client.options[:request].should be_a(Test::ResourceFindRequest)
-      client.options[:request].name.should eq('Test Name')
-      client.options[:request].active.should eq(false)
+      expect(client.options[:request]).to be_a(Test::ResourceFindRequest)
+      expect(client.options[:request].name).to eq('Test Name')
+      expect(client.options[:request].active).to eq(false)
     end
 
   end

data/spec/lib/protobuf/rpc/connector_spec.rb

@@ -9,17 +9,17 @@ describe ::Protobuf::Rpc::Connector do
 
     context 'Protobuf.connector_type is socket' do
       before { ::Protobuf.connector_type = :socket }
-      it { should eq ::Protobuf::Rpc::Connectors::Socket }
+      specify { expect(subject).to eq ::Protobuf::Rpc::Connectors::Socket }
     end
 
     context 'Protobuf.connector_type is not a known value' do
-      before { ::Protobuf.stub(:connector_type) { :foo } }
-      it { should eq ::Protobuf::Rpc::Connectors::Socket }
+      before { allow(::Protobuf).to receive(:connector_type).and_return(:foo) }
+      specify { expect(subject).to eq(::Protobuf::Rpc::Connectors::Socket) }
     end
 
     context 'Protobuf.connector_type is zmq' do
       before { ::Protobuf.connector_type = :zmq }
-      it { should eq ::Protobuf::Rpc::Connectors::Zmq }
+      specify { expect(subject).to eq(::Protobuf::Rpc::Connectors::Zmq) }
     end
   end