protobuffy 3.6.0 → 4.0.0

data/spec/lib/protobuf/rpc/middleware/response_encoder_spec.rb

@@ -1,28 +1,28 @@
 require 'spec_helper'
 
-describe Protobuf::Rpc::Middleware::ResponseEncoder do
-  let(:app) { Proc.new { |env| env.response = response; env } }
-  let(:env) {
+RSpec.describe Protobuf::Rpc::Middleware::ResponseEncoder do
+  let(:app) { proc { |env| env.response = response; env } }
+  let(:env) do
     Protobuf::Rpc::Env.new(
       'response_type' => Test::Resource,
       'log_signature' => 'log_signature'
     )
-  }
+  end
   let(:encoded_response) { response_wrapper.encode }
   let(:response) { Test::Resource.new(:name => 'required') }
-  let(:response_wrapper) { Protobuf::Socketrpc::Response.new(:response_proto => response) }
+  let(:response_wrapper) { ::Protobuf::Socketrpc::Response.new(:response_proto => response) }
 
   subject { described_class.new(app) }
 
   describe "#call" do
     it "encodes the response" do
       stack_env = subject.call(env)
-      stack_env.encoded_response.should eq encoded_response
+      expect(stack_env.encoded_response).to eq encoded_response
     end
 
     it "calls the stack" do
       stack_env = subject.call(env)
-      stack_env.response.should eq response
+      expect(stack_env.response).to eq response
     end
 
     context "when response is responds to :to_hash" do
@@ -31,7 +31,7 @@ describe Protobuf::Rpc::Middleware::ResponseEncoder do
 
       it "sets Env#response" do
         stack_env = subject.call(env)
-        stack_env.response.should eq response
+        expect(stack_env.response).to eq response
       end
     end
 
@@ -41,7 +41,7 @@ describe Protobuf::Rpc::Middleware::ResponseEncoder do
 
       it "sets Env#response" do
         stack_env = subject.call(env)
-        stack_env.response.should eq response
+        expect(stack_env.response).to eq response
       end
     end
 
@@ -60,12 +60,12 @@ describe Protobuf::Rpc::Middleware::ResponseEncoder do
 
       it "wraps and encodes the response" do
         stack_env = subject.call(env)
-        stack_env.encoded_response.should eq encoded_response
+        expect(stack_env.encoded_response).to eq encoded_response
       end
     end
 
     context "when encoding fails" do
-      before { Protobuf::Socketrpc::Response.any_instance.stub(:encode).and_raise(RuntimeError) }
+      before { allow_any_instance_of(::Protobuf::Socketrpc::Response).to receive(:encode).and_raise(RuntimeError) }
 
       it "raises a bad request data exception" do
         expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::PbError)

data/spec/lib/protobuf/rpc/middleware/statsd_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 require 'timecop'
 
 describe Protobuf::Rpc::Middleware::Statsd do
-  let(:app) { Proc.new { |inner_env| Timecop.freeze(Time.now + call_time); inner_env } }
-  let(:env) {
+  let(:app) { proc { |inner_env| Timecop.freeze(Time.now + call_time); inner_env } }
+  let(:env) do
     Protobuf::Rpc::Env.new(
       'client_host' => 'client_host.test.co',
       'encoded_request' => request_wrapper.encode,
@@ -15,19 +15,19 @@ describe Protobuf::Rpc::Middleware::Statsd do
       'response_type' => rpc_method.response_type,
       'rpc_method' => rpc_method,
       'rpc_service' => service_class,
-      'service_name' => service_name,
+      'service_name' => service_name
     )
-  }
+  end
   let(:method_name) { :find }
   let(:request) { request_type.new(:name => 'required') }
   let(:request_type) { rpc_method.request_type }
-  let(:request_wrapper) {
+  let(:request_wrapper) do
     Protobuf::Socketrpc::Request.new(
       :service_name => service_name,
       :method_name => method_name.to_s,
       :request_proto => request
     )
-  }
+  end
   let(:response) { rpc_method.response_type.new(:name => 'required') }
   let(:response_wrapper) { Protobuf::Socketrpc::Response.new(:response_proto => response) }
   let(:rpc_method) { service_class.rpcs[method_name] }

data/spec/lib/protobuf/rpc/servers/http/server_spec.rb

@@ -17,8 +17,9 @@ module ReverseModule
     rpc :reverse, ReverseRequest, ReverseResponse
     def reverse
       respond_with :reversed => request.input.reverse,
-                   :some_reversed_header => env.parent_env.has_key?('X-SOME-HEADER') ?
-                                            env.parent_env['X-SOME-HEADER'].reverse : nil
+                   :some_reversed_header => if env.parent_env.key?('X-SOME-HEADER')
+                                              env.parent_env['X-SOME-HEADER'].reverse
+                                            end
     end
   end
 end
@@ -33,79 +34,81 @@ describe Protobuf::Rpc::Http::Server do
     end
 
     it 'should return the correct response for ReverseModule::ReverseService.reverse' do
-      response = client.post "/ReverseModule%3A%3AReverseService/reverse", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode()
-      response.status.should eq 200
-      response.headers['content-type'].should eq "application/x-protobuf"
-      response.headers['x-protobuf-error'].should be_nil
-      response.headers['x-protobuf-error-reason'].should be_nil
-      response.body.should eq ReverseModule::ReverseResponse.new(:reversed => "hello world".reverse).encode()
+      response = client.post "/ReverseModule%3A%3AReverseService/reverse", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode
+      expect(response.status).to eq 200
+      expect(response.headers['content-type']).to eq "application/x-protobuf"
+      expect(response.headers['x-protobuf-error']).to be_nil
+      expect(response.headers['x-protobuf-error-reason']).to be_nil
+      expect(response.body).to eq ReverseModule::ReverseResponse.new(:reversed => "hello world".reverse).encode
     end
 
     it 'should return the correct response for ReverseModule::ReverseService.reverse when some header is passed' do
       response = client.post "/ReverseModule%3A%3AReverseService/reverse",
-                             :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode(),
+                             :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode,
                              "X-SOME-HEADER" => "yes i am"
-      response.status.should eq 200
-      response.headers['content-type'].should eq "application/x-protobuf"
-      response.headers['x-protobuf-error'].should be_nil
-      response.headers['x-protobuf-error-reason'].should be_nil
-      response.body.should eq ReverseModule::ReverseResponse.new(:reversed => "hello world".reverse,
-                                                                 :some_reversed_header => "yes i am".reverse).encode()
+      expect(response.status).to eq 200
+      expect(response.headers['content-type']).to eq "application/x-protobuf"
+      expect(response.headers['x-protobuf-error']).to be_nil
+      expect(response.headers['x-protobuf-error-reason']).to be_nil
+      expect(response.body).to eq ReverseModule::ReverseResponse.new(
+        :reversed             => "hello world".reverse,
+        :some_reversed_header => "yes i am".reverse
+      ).encode
     end
 
     it 'should return METHOD_NOT_FOUND for ReverseModule::ReverseService.bobloblaw' do
-      response = client.post "/ReverseModule%3A%3AReverseService/bobloblaw", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode()
-      response.status.should eq 404
-      response.headers['content-type'].should eq "application/x-protobuf"
-      response.headers['x-protobuf-error'].should eq "ReverseModule::ReverseService#bobloblaw is not a defined RPC method."
-      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::METHOD_NOT_FOUND.to_s
-      response.body.should eq ""
+      response = client.post "/ReverseModule%3A%3AReverseService/bobloblaw", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode
+      expect(response.status).to eq 404
+      expect(response.headers['content-type']).to eq "application/x-protobuf"
+      expect(response.headers['x-protobuf-error']).to eq "ReverseModule::ReverseService#bobloblaw is not a defined RPC method."
+      expect(response.headers['x-protobuf-error-reason']).to eq Protobuf::Socketrpc::ErrorReason::METHOD_NOT_FOUND.to_s
+      expect(response.body).to eq ""
     end
 
     it 'should return SERVICE_NOT_FOUND for Bar::ReverseService.reverse' do
-      response = client.post "/Bar%3A%3AReverseService/reverse", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode()
-      response.status.should eq 404
-      response.headers['content-type'].should eq "application/x-protobuf"
-      response.headers['x-protobuf-error'].should eq "Service class Bar::ReverseService is not defined."
-      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::SERVICE_NOT_FOUND.to_s
-      response.body.should eq ""
+      response = client.post "/Bar%3A%3AReverseService/reverse", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode
+      expect(response.status).to eq 404
+      expect(response.headers['content-type']).to eq "application/x-protobuf"
+      expect(response.headers['x-protobuf-error']).to eq "Service class Bar::ReverseService is not defined."
+      expect(response.headers['x-protobuf-error-reason']).to eq Protobuf::Socketrpc::ErrorReason::SERVICE_NOT_FOUND.to_s
+      expect(response.body).to eq ""
     end
 
     it 'should return RPC_FAILED for missing input' do
       response = client.post "/ReverseModule%3A%3AReverseService/reverse", :input => ""
-      response.status.should eq 500
-      response.headers['content-type'].should eq "application/x-protobuf"
-      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::RPC_FAILED.to_s
-      response.body.should eq ""
+      expect(response.status).to eq 400
+      expect(response.headers['content-type']).to eq "application/x-protobuf"
+      expect(response.headers['x-protobuf-error-reason']).to eq Protobuf::Socketrpc::ErrorReason::BAD_REQUEST_DATA.to_s
+      expect(response.body).to eq ""
     end
 
     it 'should return RPC_ERROR for invalid input' do
       response = client.post "/ReverseModule%3A%3AReverseService/reverse", :input => "\\n\\x03foo"
-      response.status.should eq 500
-      response.headers['content-type'].should eq "application/x-protobuf"
-      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::RPC_ERROR.to_s
-      response.body.should eq ""
+      expect(response.status).to eq 400
+      expect(response.headers['content-type']).to eq "application/x-protobuf"
+      expect(response.headers['x-protobuf-error-reason']).to eq Protobuf::Socketrpc::ErrorReason::BAD_REQUEST_DATA.to_s
+      expect(response.body).to eq ""
     end
 
     it 'should return INVALID_REQUEST_PROTO for invalid URL' do
-      response = client.post "/foo", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode()
-      response.status.should eq 400
-      response.headers['content-type'].should eq "application/x-protobuf"
-      # response.headers['x-protobuf-error'].should eq "Service class Bar::ReverseService is not defined."
-      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::INVALID_REQUEST_PROTO.to_s
-      response.body.should eq ""
+      response = client.post "/foo", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode
+      expect(response.status).to eq 400
+      expect(response.headers['content-type']).to eq "application/x-protobuf"
+      expect(response.headers['x-protobuf-error']).to eq "Expected path format /CLASS/METHOD"
+      expect(response.headers['x-protobuf-error-reason']).to eq Protobuf::Socketrpc::ErrorReason::INVALID_REQUEST_PROTO.to_s
+      expect(response.body).to eq ""
     end
   end
 
   describe '.running?' do
     it 'returns true if running' do
       subject.instance_variable_set(:@running, true)
-      subject.running?.should be_true
+      expect(subject.running?).to be true
     end
 
     it 'returns false if not running' do
       subject.instance_variable_set(:@running, false)
-      subject.running?.should be_false
+      expect(subject.running?).to be false
     end
   end
 
@@ -113,7 +116,7 @@ describe Protobuf::Rpc::Http::Server do
     it 'sets running to false' do
       # subject.instance_variable_set(:@workers, [])
       subject.stop
-      subject.instance_variable_get(:@running).should be_false
+      expect(subject.instance_variable_get(:@running)).to be_falsey
     end
   end
 end

data/spec/lib/protobuf/rpc/servers/socket_server_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
-require 'spec/support/test/resource_service'
 require 'protobuf/rpc/servers/socket_runner'
 require 'protobuf/socket'
+require SUPPORT_PATH.join('resource_service')
 
-describe Protobuf::Rpc::Socket::Server do
+RSpec.describe Protobuf::Rpc::Socket::Server do
   before(:each) do
     load 'protobuf/socket.rb'
   end
@@ -14,7 +14,7 @@ describe Protobuf::Rpc::Socket::Server do
     @options = OpenStruct.new(:host => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
     @runner = ::Protobuf::Rpc::SocketRunner.new(@options)
     @server = @runner.instance_variable_get(:@server)
-    @server_thread = Thread.new(@runner) { |runner| runner.run }
+    @server_thread = Thread.new(@runner, &:run)
     Thread.pass until @server.running?
   end
 
@@ -24,15 +24,15 @@ describe Protobuf::Rpc::Socket::Server do
   end
 
   it "Runner provides a stop method" do
-    @runner.should respond_to(:stop)
+    expect(@runner).to respond_to(:stop)
   end
 
   it "provides a stop method" do
-    @server.should respond_to(:stop)
+    expect(@server).to respond_to(:stop)
   end
 
   it "signals the Server is running" do
-    @server.should be_running
+    expect(@server).to be_running
   end
 
 end

data/spec/lib/protobuf/rpc/servers/zmq/server_spec.rb

@@ -1,15 +1,17 @@
 require 'spec_helper'
 require 'protobuf/rpc/servers/zmq/server'
 
-describe Protobuf::Rpc::Zmq::Server do
+RSpec.describe Protobuf::Rpc::Zmq::Server do
   subject { described_class.new(options) }
 
-  let(:options) {{
-    :host => '127.0.0.1',
-    :port => 9399,
-    :worker_port => 9400,
-    :workers_only => true
-  }}
+  let(:options) do
+    {
+      :host => '127.0.0.1',
+      :port => 9399,
+      :worker_port => 9400,
+      :workers_only => true,
+    }
+  end
 
   before do
     load 'protobuf/zmq.rb'
@@ -22,12 +24,12 @@ describe Protobuf::Rpc::Zmq::Server do
   describe '.running?' do
     it 'returns true if running' do
       subject.instance_variable_set(:@running, true)
-      subject.running?.should be_true
+      expect(subject.running?).to be true
     end
 
     it 'returns false if not running' do
       subject.instance_variable_set(:@running, false)
-      subject.running?.should be_false
+      expect(subject.running?).to be false
     end
   end
 
@@ -35,7 +37,7 @@ describe Protobuf::Rpc::Zmq::Server do
     it 'sets running to false' do
       subject.instance_variable_set(:@workers, [])
       subject.stop
-      subject.instance_variable_get(:@running).should be_false
+      expect(subject.instance_variable_get(:@running)).to be false
     end
   end
 end

data/spec/lib/protobuf/rpc/servers/zmq/util_spec.rb

@@ -4,7 +4,7 @@ class UtilTest
   include ::Protobuf::Rpc::Zmq::Util
 end
 
-describe ::Protobuf::Rpc::Zmq::Util do
+RSpec.describe ::Protobuf::Rpc::Zmq::Util do
   before(:each) do
     load 'protobuf/zmq.rb'
   end
@@ -12,34 +12,34 @@ describe ::Protobuf::Rpc::Zmq::Util do
   subject { UtilTest.new }
   describe '#zmq_error_check' do
     it 'raises when the error code is less than 0' do
-      expect {
+      expect do
         subject.zmq_error_check(-1, :test)
-      }.to raise_error(/test/)
+      end.to raise_error(/test/)
     end
 
     it 'retrieves the error string from ZeroMQ' do
-      ZMQ::Util.stub(:error_string).and_return('an error from zmq')
-      expect {
+      allow(ZMQ::Util).to receive(:error_string).and_return('an error from zmq')
+      expect do
         subject.zmq_error_check(-1, :test)
-      }.to raise_error(RuntimeError, /an error from zmq/i)
+      end.to raise_error(RuntimeError, /an error from zmq/i)
     end
 
     it 'does nothing if the error code is > 0' do
-      expect {
+      expect do
         subject.zmq_error_check(1, :test)
-      }.to_not raise_error
+      end.to_not raise_error
     end
 
     it 'does nothing if the error code is == 0' do
-      expect {
+      expect do
         subject.zmq_error_check(0, :test)
-      }.to_not raise_error
+      end.to_not raise_error
     end
   end
 
   describe '#log_signature' do
     it 'returns the signature for the log' do
-      subject.log_signature.should include('server', 'UtilTest')
+      expect(subject.log_signature).to include('server', 'UtilTest')
     end
   end
 

data/spec/lib/protobuf/rpc/servers/zmq/worker_spec.rb

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
-describe ::Protobuf::Rpc::Zmq::Worker do
-  before(:each) do 
+RSpec.describe ::Protobuf::Rpc::Zmq::Worker do
+  before(:each) do
     load 'protobuf/zmq.rb'
 
     fake_socket = double
-    fake_socket.should_receive(:connect).and_return(0)
-    fake_socket.should_receive(:send_string).and_return(0)
+    expect(fake_socket).to receive(:connect).and_return(0)
+    expect(fake_socket).to receive(:send_string).and_return(0)
 
     fake_context = double
-    fake_context.should_receive(:socket).and_return( fake_socket )
-    ::ZMQ::Context.should_receive(:new).and_return( fake_context )
+    expect(fake_context).to receive(:socket).and_return(fake_socket)
+    expect(::ZMQ::Context).to receive(:new).and_return(fake_context)
   end
 
   subject do
-    described_class.new({ :host => '127.0.0.1', :port => 9400 })
+    described_class.new(:host => '127.0.0.1', :port => 9400)
   end
 
   describe '#run' do

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

@@ -2,48 +2,48 @@ require 'spec_helper'
 
 require 'protobuf/rpc/service_directory'
 
-describe ::Protobuf::Rpc::ServiceDirectory do
+RSpec.describe ::Protobuf::Rpc::ServiceDirectory do
   subject { described_class.instance }
 
-  let(:echo_server) {
+  let(:echo_server) do
     ::Protobuf::Rpc::DynamicDiscovery::Server.new(
       :uuid => 'echo',
       :address => '127.0.0.1',
       :port => '1111',
       :ttl => 10,
-      :services => %w[EchoService]
+      :services => %w(EchoService)
     )
-  }
+  end
 
-  let(:hello_server) {
+  let(:hello_server) do
     ::Protobuf::Rpc::DynamicDiscovery::Server.new(
       :uuid => "hello",
       :address => '127.0.0.1',
       :port => "1112",
       :ttl => 10,
-      :services => %w[HelloService]
+      :services => %w(HelloService)
     )
-  }
+  end
 
-  let(:hello_server_with_short_ttl) {
+  let(:hello_server_with_short_ttl) do
     ::Protobuf::Rpc::DynamicDiscovery::Server.new(
       :uuid => "hello_server_with_short_ttl",
       :address => '127.0.0.1',
       :port => '1113',
       :ttl => 1,
-      :services => %w[HelloService]
+      :services => %w(HelloService)
     )
-  }
+  end
 
-  let(:combo_server) {
+  let(:combo_server) do
     ::Protobuf::Rpc::DynamicDiscovery::Server.new(
       :uuid => "combo",
       :address => '127.0.0.1',
       :port => '1114',
       :ttl => 10,
-      :services => %w[HelloService EchoService]
+      :services => %w(HelloService EchoService)
     )
-  }
+  end
 
   before(:all) do
     @address = "127.0.0.1"
@@ -56,10 +56,8 @@ describe ::Protobuf::Rpc::ServiceDirectory do
   end
 
   def expect_event_trigger(event)
-    ::ActiveSupport::Notifications
-      .should_receive(:instrument)
-      .with(event, hash_including(:listing => an_instance_of(::Protobuf::Rpc::ServiceDirectory::Listing)))
-      .once
+    expect(::ActiveSupport::Notifications).to receive(:instrument)
+      .with(event, hash_including(:listing => an_instance_of(::Protobuf::Rpc::ServiceDirectory::Listing))).once
   end
 
   def send_beacon(type, server)
@@ -74,29 +72,29 @@ describe ::Protobuf::Rpc::ServiceDirectory do
   end
 
   it "should be a singleton" do
-    subject.should be_a_kind_of(Singleton)
+    expect(subject).to be_a_kind_of(Singleton)
   end
 
   it "should be configured to listen to address 127.0.0.1" do
-    described_class.address.should eq '127.0.0.1'
+    expect(described_class.address).to eq '127.0.0.1'
   end
 
   it "should be configured to listen to port 33333" do
-    described_class.port.should eq 33333
+    expect(described_class.port).to eq 33333
   end
 
   it "should defer .start to the instance#start" do
-    described_class.instance.should_receive(:start)
+    expect(described_class.instance).to receive(:start)
     described_class.start
   end
 
   it "should yeild itself to blocks passed to .start" do
-    described_class.instance.stub(:start)
+    allow(described_class.instance).to receive(:start)
     expect { |b| described_class.start(&b) }.to yield_with_args(described_class)
   end
 
   it "should defer .stop to the instance#stop" do
-    described_class.instance.should_receive(:stop)
+    expect(described_class.instance).to receive(:stop)
     described_class.stop
   end
 
@@ -106,20 +104,20 @@ describe ::Protobuf::Rpc::ServiceDirectory do
     describe "#lookup" do
       it "should return nil" do
         send_beacon(:heartbeat, echo_server)
-        subject.lookup("EchoService").should be_nil
+        expect(subject.lookup("EchoService")).to be_nil
       end
     end
 
     describe "#restart" do
       it "should start the service" do
         subject.restart
-        subject.should be_running
+        expect(subject).to be_running
       end
     end
 
     describe "#running" do
       it "should be false" do
-        subject.should_not be_running
+        expect(subject).to_not be_running
       end
     end
 
@@ -134,7 +132,7 @@ describe ::Protobuf::Rpc::ServiceDirectory do
     before { subject.start }
     after { subject.stop }
 
-    it { should be_running }
+    specify { expect(subject).to be_running }
 
     it "should trigger added events" do
       expect_event_trigger("directory.listing.added")
@@ -159,13 +157,13 @@ describe ::Protobuf::Rpc::ServiceDirectory do
           send_beacon(:heartbeat, hello_server)
           send_beacon(:heartbeat, combo_server)
 
-          subject.all_listings_for("HelloService").size.should eq(2)
+          expect(subject.all_listings_for("HelloService").size).to eq(2)
         end
       end
 
       context "when no listings are present" do
         it "returns and empty array" do
-          subject.all_listings_for("HelloService").size.should eq(0)
+          expect(subject.all_listings_for("HelloService").size).to eq(0)
         end
       end
     end
@@ -176,16 +174,16 @@ describe ::Protobuf::Rpc::ServiceDirectory do
         send_beacon(:heartbeat, echo_server)
         send_beacon(:heartbeat, combo_server)
 
-        expect { |block|
+        expect do |block|
           subject.each_listing(&block)
-        }.to yield_control.exactly(3).times
+        end.to yield_control.exactly(3).times
       end
     end
 
     describe "#lookup" do
       it "should provide listings by service" do
         send_beacon(:heartbeat, hello_server)
-        subject.lookup("HelloService").to_hash.should eq hello_server.to_hash
+        expect(subject.lookup("HelloService").to_hash).to eq hello_server.to_hash
       end
 
       it "should return random listings" do
@@ -193,14 +191,14 @@ describe ::Protobuf::Rpc::ServiceDirectory do
         send_beacon(:heartbeat, combo_server)
 
         uuids = 100.times.map { subject.lookup("HelloService").uuid }
-        uuids.count("hello").should be_within(25).of(50)
-        uuids.count("combo").should be_within(25).of(50)
+        expect(uuids.count("hello")).to be_within(25).of(50)
+        expect(uuids.count("combo")).to be_within(25).of(50)
       end
 
       it "should not return expired listings" do
         send_beacon(:heartbeat, hello_server_with_short_ttl)
-        sleep 1
-        subject.lookup("HelloService").should be_nil
+        sleep 5
+        expect(subject.lookup("HelloService")).to be_nil
       end
 
       it "should not return flatlined servers" do
@@ -209,7 +207,7 @@ describe ::Protobuf::Rpc::ServiceDirectory do
         send_beacon(:flatline, echo_server)
 
         uuids = 100.times.map { subject.lookup("EchoService").uuid }
-        uuids.count("combo").should eq 100
+        expect(uuids.count("combo")).to eq 100
       end
 
       it "should return up-to-date listings" do
@@ -217,13 +215,13 @@ describe ::Protobuf::Rpc::ServiceDirectory do
         echo_server.port = "7777"
         send_beacon(:heartbeat, echo_server)
 
-        subject.lookup("EchoService").port.should eq "7777"
+        expect(subject.lookup("EchoService").port).to eq "7777"
       end
 
       context 'when given service identifier is a class name' do
         it 'returns the listing corresponding to the class name' do
           send_beacon(:heartbeat, echo_server)
-          subject.lookup(EchoService).uuid.should eq echo_server.uuid
+          expect(subject.lookup(EchoService).uuid).to eq echo_server.uuid
         end
       end
     end
@@ -233,13 +231,13 @@ describe ::Protobuf::Rpc::ServiceDirectory do
         send_beacon(:heartbeat, echo_server)
         send_beacon(:heartbeat, combo_server)
         subject.restart
-        subject.lookup("EchoService").should be_nil
+        expect(subject.lookup("EchoService")).to be_nil
       end
     end
 
     describe "#running" do
       it "should be true" do
-        subject.should be_running
+        expect(subject).to be_running
       end
     end
 
@@ -248,29 +246,29 @@ describe ::Protobuf::Rpc::ServiceDirectory do
         send_beacon(:heartbeat, echo_server)
         send_beacon(:heartbeat, combo_server)
         subject.stop
-        subject.lookup("EchoService").should be_nil
+        expect(subject.lookup("EchoService")).to be_nil
       end
 
       it "should stop the server" do
         subject.stop
-        subject.should_not be_running
+        expect(subject).to_not be_running
       end
     end
   end
 
   if ENV.key?("BENCH")
     context "performance" do
-      let(:servers) {
-        100.times.collect do |x|
+      let(:servers) do
+        100.times.map do |x|
           ::Protobuf::Rpc::DynamicDiscovery::Server.new(
             :uuid => "performance_server#{x + 1}",
             :address => '127.0.0.1',
             :port => (5555 + x).to_s,
             :ttl => rand(1..5),
-            :services => 10.times.collect { |y| "PerformanceService#{y}" }
+            :services => 10.times.map { |y| "PerformanceService#{y}" }
           )
         end
-      }
+      end
 
       before do
         require 'benchmark'
@@ -285,8 +283,8 @@ describe ::Protobuf::Rpc::ServiceDirectory do
       it "should perform lookups in constant time" do
         print "\n\n"
         Benchmark.bm(17) do |x|
-          x.report("  1_000 lookups:") {   1_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
-          x.report(" 10_000 lookups:") {  10_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
+          x.report("  1_000 lookups:") { 1_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
+          x.report(" 10_000 lookups:") { 10_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
           x.report("100_000 lookups:") { 100_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
         end
       end