protobuf 3.0.4 → 3.0.5

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

@@ -17,12 +17,12 @@ describe Protobuf::Rpc::Middleware::ResponseEncoder do
   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/servers/socket_server_spec.rb

@@ -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

@@ -22,12 +22,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_truthy
     end
 
     it 'returns false if not running' do
       subject.instance_variable_set(:@running, false)
-      subject.running?.should be_false
+      expect(subject.running?).to be_falsey
     end
   end
 
@@ -35,7 +35,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_falsey
     end
   end
 end

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

@@ -18,7 +18,7 @@ describe ::Protobuf::Rpc::Zmq::Util do
     end
 
     it 'retrieves the error string from ZeroMQ' do
-      ZMQ::Util.stub(:error_string).and_return('an error from zmq')
+      allow(ZMQ::Util).to receive(:error_string).and_return('an error from zmq')
       expect {
         subject.zmq_error_check(-1, :test)
       }.to raise_error(RuntimeError, /an error from zmq/i)
@@ -39,7 +39,7 @@ describe ::Protobuf::Rpc::Zmq::Util do
 
   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,16 +1,16 @@
 require 'spec_helper'
 
 describe ::Protobuf::Rpc::Zmq::Worker do
-  before(:each) 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

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

@@ -56,10 +56,9 @@ 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 +73,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 +105,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 +133,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 +158,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
@@ -185,7 +184,7 @@ describe ::Protobuf::Rpc::ServiceDirectory do
     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 +192,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
+        expect(subject.lookup("HelloService")).to be_nil
       end
 
       it "should not return flatlined servers" do
@@ -209,7 +208,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 +216,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 +232,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,12 +247,12 @@ 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

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

@@ -23,14 +23,14 @@ describe Protobuf::Rpc::ServiceDispatcher do
 
   subject { described_class.new(app) }
 
-  before { subject.stub(:rpc_service).and_return(rpc_service) }
+  before { allow(subject).to receive(:rpc_service).and_return(rpc_service) }
 
   describe '#call' do
-    before { rpc_service.stub(:response).and_return(response) }
+    before { allow(rpc_service).to receive(:response).and_return(response) }
 
     it "dispatches the request" do
       stack_env = subject.call(env)
-      stack_env.response.should eq response
+      expect(stack_env.response).to eq response
     end
 
     context "when the given RPC method is not implemented" do
@@ -42,7 +42,7 @@ describe Protobuf::Rpc::ServiceDispatcher do
     end
 
     context "when the given RPC method is implemented and a NoMethodError is raised" do
-      before { rpc_service.stub(:callable_rpc_method).and_return(lambda { rpc_service.__send__(:foo) }) }
+      before { allow(rpc_service).to receive(:callable_rpc_method).and_return(lambda { rpc_service.__send__(:foo) }) }
 
       it "raises the exeception" do
         expect { subject.call(env) }.to raise_exception(NoMethodError)

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

@@ -55,13 +55,13 @@ describe Protobuf::Rpc::ServiceFilters do
       FilterTest.before_filter(:foo)
     end
 
-    specify { subject.class.should respond_to(:before_filter) }
-    specify { subject.class.should respond_to(:before_action) }
+    specify { expect(subject.class).to respond_to(:before_filter) }
+    specify { expect(subject.class).to respond_to(:before_action) }
 
     it 'calls filters in the order they were defined' do
       subject.__send__(:run_filters, :endpoint)
-      subject.called.should eq [ :verify_before, :foo, :endpoint ]
-      subject.before_filter_calls.should eq 1
+      expect(subject.called).to eq [ :verify_before, :foo, :endpoint ]
+      expect(subject.before_filter_calls).to eq 1
     end
 
     context 'when filter is configured with "only"' do
@@ -82,14 +82,14 @@ describe Protobuf::Rpc::ServiceFilters do
       context 'when invoking a method defined in "only" option' do
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint_with_verify)
-          subject.called.should eq [ :verify_before, :endpoint_with_verify ]
+          expect(subject.called).to eq [ :verify_before, :endpoint_with_verify ]
         end
       end
 
       context 'when invoking a method not defined by "only" option' do
         it 'does not invoke the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to eq [ :endpoint ]
         end
       end
     end
@@ -112,14 +112,14 @@ describe Protobuf::Rpc::ServiceFilters do
       context 'when invoking a method not defined in "except" option' do
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to eq [ :verify_before, :endpoint ]
         end
       end
 
       context 'when invoking a method defined by "except" option' do
         it 'does not invoke the filter' do
           subject.__send__(:run_filters, :endpoint_without_verify)
-          subject.called.should eq [ :endpoint_without_verify ]
+          expect(subject.called).to eq [ :endpoint_without_verify ]
         end
       end
     end
@@ -142,7 +142,7 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to eq [ :verify_before, :endpoint ]
         end
       end
 
@@ -154,7 +154,7 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to eq [ :verify_before, :endpoint ]
         end
       end
 
@@ -166,7 +166,7 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'skips the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to eq [ :endpoint ]
         end
       end
 
@@ -178,7 +178,7 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'skips the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to eq [ :endpoint ]
         end
       end
     end
@@ -201,7 +201,7 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to eq [ :verify_before, :endpoint ]
         end
       end
 
@@ -213,7 +213,7 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'invokes the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :verify_before, :endpoint ]
+          expect(subject.called).to eq [ :verify_before, :endpoint ]
         end
       end
 
@@ -225,7 +225,7 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'skips the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to eq [ :endpoint ]
         end
       end
 
@@ -237,7 +237,7 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'skips the filter' do
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq [ :endpoint ]
+          expect(subject.called).to eq [ :endpoint ]
         end
       end
     end
@@ -259,9 +259,9 @@ describe Protobuf::Rpc::ServiceFilters do
       end
 
       it 'does not invoke the rpc method' do
-        subject.should_not_receive(:endpoint)
+        expect(subject).not_to receive(:endpoint)
         subject.__send__(:run_filters, :endpoint)
-        subject.called.should eq [ :short_circuit_filter ]
+        expect(subject.called).to eq [ :short_circuit_filter ]
       end
     end
   end
@@ -289,13 +289,13 @@ describe Protobuf::Rpc::ServiceFilters do
       FilterTest.after_filter(:foo)
     end
 
-    specify { subject.class.should respond_to(:after_filter) }
-    specify { subject.class.should respond_to(:after_action) }
+    specify { expect(subject.class).to respond_to(:after_filter) }
+    specify { expect(subject.class).to respond_to(:after_action) }
 
     it 'calls filters in the order they were defined' do
       subject.__send__(:run_filters, :endpoint)
-      subject.called.should eq [ :endpoint, :verify_after, :foo ]
-      subject.after_filter_calls.should eq 1
+      expect(subject.called).to eq [ :endpoint, :verify_after, :foo ]
+      expect(subject.after_filter_calls).to eq 1
     end
   end
 
@@ -326,12 +326,12 @@ describe Protobuf::Rpc::ServiceFilters do
       FilterTest.around_filter(:inner_around)
     end
 
-    specify { subject.class.should respond_to(:around_filter) }
-    specify { subject.class.should respond_to(:around_action) }
+    specify { expect(subject.class).to respond_to(:around_filter) }
+    specify { expect(subject.class).to respond_to(:around_action) }
 
     it 'calls filters in the order they were defined' do
       subject.__send__(:run_filters, :endpoint)
-      subject.called.should eq([ :outer_around_top,
+      expect(subject.called).to eq([ :outer_around_top,
                                  :inner_around_top,
                                  :endpoint,
                                  :inner_around_bottom,
@@ -354,9 +354,9 @@ describe Protobuf::Rpc::ServiceFilters do
       end
 
       it 'cancels calling the rest of the filters and the endpoint' do
-        subject.should_not_receive(:endpoint)
+        expect(subject).not_to receive(:endpoint)
         subject.__send__(:run_filters, :endpoint)
-        subject.called.should eq([ :outer_around_top,
+        expect(subject.called).to eq([ :outer_around_top,
                                    :inner_around,
                                    :outer_around_bottom ])
       end
@@ -412,10 +412,10 @@ describe Protobuf::Rpc::ServiceFilters do
 
       it 'short-circuits the call stack' do
         expect {
-          subject.should_not_receive(:endpoint)
+          expect(subject).not_to receive(:endpoint)
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq([ :filter_with_error3, :custom_error_occurred ])
-          subject.ex_class.should eq CustomError3
+          expect(subject.called).to eq([ :filter_with_error3, :custom_error_occurred ])
+          expect(subject.ex_class).to eq CustomError3
         }.not_to raise_error
       end
     end
@@ -433,10 +433,10 @@ describe Protobuf::Rpc::ServiceFilters do
 
         it 'short-circuits the call stack' do
           expect {
-            subject.should_not_receive(:endpoint)
+            expect(subject).not_to receive(:endpoint)
             subject.__send__(:run_filters, :endpoint)
-            subject.called.should eq([ :filter_with_error1, :custom_error_occurred ])
-            subject.ex_class.should eq CustomError1
+            expect(subject.called).to eq([ :filter_with_error1, :custom_error_occurred ])
+            expect(subject.ex_class).to eq CustomError1
           }.not_to raise_error
         end
       end
@@ -453,10 +453,10 @@ describe Protobuf::Rpc::ServiceFilters do
 
       it 'short-circuits the call stack' do
         expect {
-          subject.should_not_receive(:endpoint)
+          expect(subject).not_to receive(:endpoint)
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq([ :filter_with_error1, :block_rescue_handler ])
-          subject.ex_class.should eq CustomError1
+          expect(subject.called).to eq([ :filter_with_error1, :block_rescue_handler ])
+          expect(subject.ex_class).to eq CustomError1
         }.not_to raise_error
       end
     end
@@ -472,10 +472,10 @@ describe Protobuf::Rpc::ServiceFilters do
 
       it 'rescues with the given callable' do
         expect {
-          subject.should_not_receive(:endpoint)
+          expect(subject).not_to receive(:endpoint)
           subject.__send__(:run_filters, :endpoint)
-          subject.called.should eq([ :filter_with_runtime_error, :standard_error_rescue_handler ])
-          subject.ex_class.should eq RuntimeError
+          expect(subject.called).to eq([ :filter_with_runtime_error, :standard_error_rescue_handler ])
+          expect(subject.ex_class).to eq RuntimeError
         }.not_to raise_error
       end
     end