protobuf 3.0.4 → 3.0.5

data/spec/lib/protobuf/rpc/connectors/base_spec.rb

@@ -21,28 +21,28 @@ describe Protobuf::Rpc::Connectors::Base do
 
   describe '.new' do
     it 'assigns passed options and initializes success/failure callbacks' do
-      subject.options.should eq(Protobuf::Rpc::Connectors::DEFAULT_OPTIONS.merge(options))
-      subject.success_cb.should be_nil
-      subject.failure_cb.should be_nil
+      expect(subject.options).to eq(Protobuf::Rpc::Connectors::DEFAULT_OPTIONS.merge(options))
+      expect(subject.success_cb).to be_nil
+      expect(subject.failure_cb).to be_nil
     end
   end
 
   describe '#success_cb' do
     it 'allows setting the success callback and calling it' do
-      subject.success_cb.should be_nil
+      expect(subject.success_cb).to be_nil
       cb = proc {|res| raise res }
       subject.success_cb = cb
-      subject.success_cb.should eq(cb)
+      expect(subject.success_cb).to eq(cb)
       expect { subject.success_cb.call('an error from cb') }.to raise_error 'an error from cb'
     end
   end
 
   describe '#failure_cb' do
     it 'allows setting the failure callback and calling it' do
-      subject.failure_cb.should be_nil
+      expect(subject.failure_cb).to be_nil
       cb = proc {|res| raise res }
       subject.failure_cb = cb
-      subject.failure_cb.should eq(cb)
+      expect(subject.failure_cb).to eq(cb)
       expect { subject.failure_cb.call('an error from cb') }.to raise_error 'an error from cb'
     end
   end

data/spec/lib/protobuf/rpc/connectors/common_spec.rb

@@ -15,15 +15,15 @@ describe Protobuf::Rpc::Connectors::Common do
   subject { @subject ||= common_class.new(subject_options) }
 
   context "API" do
-    specify { subject.respond_to?(:any_callbacks?).should be_true }
-    specify { subject.respond_to?(:request_caller).should be_true }
-    specify { subject.respond_to?(:data_callback).should be_true }
-    specify { subject.respond_to?(:error).should be_true }
-    specify { subject.respond_to?(:fail).should be_true }
-    specify { subject.respond_to?(:complete).should be_true }
-    specify { subject.respond_to?(:parse_response).should be_true }
-    specify { subject.respond_to?(:verify_options!).should be_true }
-    specify { subject.respond_to?(:verify_callbacks).should be_true }
+    specify { expect(subject.respond_to?(:any_callbacks?)).to be_truthy }
+    specify { expect(subject.respond_to?(:request_caller)).to be_truthy }
+    specify { expect(subject.respond_to?(:data_callback)).to be_truthy }
+    specify { expect(subject.respond_to?(:error)).to be_truthy }
+    specify { expect(subject.respond_to?(:fail)).to be_truthy }
+    specify { expect(subject.respond_to?(:complete)).to be_truthy }
+    specify { expect(subject.respond_to?(:parse_response)).to be_truthy }
+    specify { expect(subject.respond_to?(:verify_options!)).to be_truthy }
+    specify { expect(subject.respond_to?(:verify_callbacks)).to be_truthy }
   end
 
   describe "#any_callbacks?" do
@@ -31,7 +31,7 @@ describe Protobuf::Rpc::Connectors::Common do
     [:@complete_cb, :@success_cb, :@failure_cb].each do |cb|
       it "returns true if #{cb} is provided" do
         subject.instance_variable_set(cb, "something")
-        subject.any_callbacks?.should be_true
+        expect(subject.any_callbacks?).to be_truthy
       end
     end
 
@@ -40,32 +40,32 @@ describe Protobuf::Rpc::Connectors::Common do
       subject.instance_variable_set(:@success_cb, nil)
       subject.instance_variable_set(:@failure_cb, nil)
 
-      subject.any_callbacks?.should be_false
+      expect(subject.any_callbacks?).to be_falsey
     end
 
   end
 
   describe '#request_caller' do
-    its(:request_caller) { should eq ::Protobuf.client_host }
+    specify { expect(subject.request_caller).to eq ::Protobuf.client_host }
 
     context 'when "client_host" option is given to initializer' do
       let(:hostname) { 'myhost.myserver.com' }
       let(:subject_options) { { :client_host => hostname } }
 
-      its(:request_caller) { should_not eq ::Protobuf.client_host }
-      its(:request_caller) { should eq hostname }
+      specify { expect(subject.request_caller).to_not eq ::Protobuf.client_host }
+      specify { expect(subject.request_caller).to eq hostname }
     end
   end
 
   describe "#data_callback" do
     it "changes state to use the data callback" do
       subject.data_callback("data")
-      subject.instance_variable_get(:@used_data_callback).should be_true
+      expect(subject.instance_variable_get(:@used_data_callback)).to be_truthy
     end
 
     it "sets the data var when using the data_callback" do
       subject.data_callback("data")
-      subject.instance_variable_get(:@data).should eq("data")
+      expect(subject.instance_variable_get(:@data)).to eq("data")
     end
   end
 
@@ -84,38 +84,38 @@ describe Protobuf::Rpc::Connectors::Common do
                                                           :request_proto => '',
                                                           :caller => client_host }) }
 
-    before { subject.stub(:validate_request_type!).and_return(true) }
-    before { subject.should_not_receive(:fail) }
+    before { allow(subject).to receive(:validate_request_type!).and_return(true) }
+    before { expect(subject).not_to receive(:fail) }
 
-    its(:request_bytes) { should eq expected.encode }
+    specify { expect(subject.request_bytes).to eq expected.encode }
   end
 
   describe "#verify_callbacks" do
 
     it "sets @failure_cb to #data_callback when no callbacks are defined" do
       subject.verify_callbacks
-      subject.instance_variable_get(:@failure_cb).should eq(subject.method(:data_callback))
+      expect(subject.instance_variable_get(:@failure_cb)).to eq(subject.method(:data_callback))
     end
 
     it "sets @success_cb to #data_callback when no callbacks are defined" do
       subject.verify_callbacks
-      subject.instance_variable_get(:@success_cb).should eq(subject.method(:data_callback))
+      expect(subject.instance_variable_get(:@success_cb)).to eq(subject.method(:data_callback))
     end
 
     it "doesn't set @failure_cb when already defined" do
       set_cb = lambda{ true }
       subject.instance_variable_set(:@failure_cb, set_cb)
       subject.verify_callbacks
-      subject.instance_variable_get(:@failure_cb).should eq(set_cb)
-      subject.instance_variable_get(:@failure_cb).should_not eq(subject.method(:data_callback))
+      expect(subject.instance_variable_get(:@failure_cb)).to eq(set_cb)
+      expect(subject.instance_variable_get(:@failure_cb)).to_not eq(subject.method(:data_callback))
     end
 
     it "doesn't set @success_cb when already defined" do
       set_cb = lambda{ true }
       subject.instance_variable_set(:@success_cb, set_cb)
       subject.verify_callbacks
-      subject.instance_variable_get(:@success_cb).should eq(set_cb)
-      subject.instance_variable_get(:@success_cb).should_not eq(subject.method(:data_callback))
+      expect(subject.instance_variable_get(:@success_cb)).to eq(set_cb)
+      expect(subject.instance_variable_get(:@success_cb)).to_not eq(subject.method(:data_callback))
     end
 
   end
@@ -123,33 +123,31 @@ describe Protobuf::Rpc::Connectors::Common do
   shared_examples "a ConnectorDisposition" do |meth, cb, *args|
 
     it "calls #complete before exit" do
-      stats = double("Object")
-      stats.stub(:stop) { true }
-      subject.stats = stats
+      subject.stats = double("Object", :stop => true)
 
-      subject.should_receive(:complete)
+      expect(subject).to receive(:complete)
       subject.method(meth).call(*args)
     end
 
     it "calls the #{cb} callback when provided" do
       stats = double("Object")
-      stats.stub(:stop) { true }
+      allow(stats).to receive(:stop).and_return(true)
       subject.stats = stats
       _cb = double("Object")
 
       subject.instance_variable_set("@#{cb}", _cb)
-      _cb.should_receive(:call).and_return(true)
+      expect(_cb).to receive(:call).and_return(true)
       subject.method(meth).call(*args)
     end
 
     it "calls the complete callback when provided" do
       stats = double("Object")
-      stats.stub(:stop) { true }
+      allow(stats).to receive(:stop).and_return(true)
       subject.stats = stats
       comp_cb = double("Object")
 
       subject.instance_variable_set(:@complete_cb, comp_cb)
-      comp_cb.should_receive(:call).and_return(true)
+      expect(comp_cb).to receive(:call).and_return(true)
       subject.method(meth).call(*args)
     end
 

data/spec/lib/protobuf/rpc/connectors/socket_spec.rb

@@ -6,10 +6,10 @@ shared_examples "a Protobuf Connector" do
 
   context "API" do
     # Check the API
-    specify{ subject.respond_to?(:send_request, true).should be_true }
-    specify{ subject.respond_to?(:post_init, true).should be_true }
-    specify{ subject.respond_to?(:close_connection, true).should be_true }
-    specify{ subject.respond_to?(:error?, true).should be_true }
+    specify { expect(subject.respond_to?(:send_request, true)).to be_truthy }
+    specify { expect(subject.respond_to?(:post_init, true)).to be_truthy }
+    specify { expect(subject.respond_to?(:close_connection, true)).to be_truthy }
+    specify { expect(subject.respond_to?(:error?, true)).to be_truthy }
   end
 end
 
@@ -18,19 +18,19 @@ describe Protobuf::Rpc::Connectors::Socket do
 
   it_behaves_like "a Protobuf Connector"
 
-  specify{ described_class.include?(Protobuf::Rpc::Connectors::Common).should be_true }
+  specify { expect(described_class.include?(Protobuf::Rpc::Connectors::Common)).to be_truthy }
 
   context "#read_response" do
-    let(:data){ "New data" }
+    let(:data) { "New data" }
 
     it "fills the buffer with data from the socket" do
       socket = StringIO.new("#{data.bytesize}-#{data}")
       subject.instance_variable_set(:@socket, socket)
       subject.instance_variable_set(:@stats, OpenStruct.new)
-      subject.should_receive(:parse_response).and_return(true)
+      expect(subject).to receive(:parse_response).and_return(true)
 
       subject.__send__(:read_response)
-      subject.instance_variable_get(:@response_data).should eq(data)
+      expect(subject.instance_variable_get(:@response_data)).to eq(data)
     end
   end
 end

data/spec/lib/protobuf/rpc/connectors/zmq_spec.rb

@@ -12,20 +12,11 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
     :port => "9400"
   }}
 
-  let(:socket_double) do
-    sm = double(::ZMQ::Socket)
-    sm.stub(:connect).and_return(0)
-    sm
-  end
-
-  let(:zmq_context_double) do
-    zc = double(::ZMQ::Context)
-    zc.stub(:socket).and_return(socket_double)
-    zc
-  end
+  let(:socket_double) { double(::ZMQ::Socket, :connect => 0) }
+  let(:zmq_context_double) { double(::ZMQ::Context, :socket => socket_double) }
 
   before do
-    ::ZMQ::Context.stub(:new).and_return(zmq_context_double)
+    allow(::ZMQ::Context).to receive(:new).and_return(zmq_context_double)
   end
 
   before(:all) do
@@ -42,19 +33,17 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
     let(:listings) { [listing] }
     let(:running?) { true }
 
-    before do
-      subject.stub(:service_directory) { service_directory }
-    end
+    before { allow(subject).to receive(:service_directory).and_return(service_directory) }
 
     context "when the service directory is running" do
       it "searches the service directory" do
-        service_directory.stub(:all_listings_for).and_return(listings)
-        subject.send(:lookup_server_uri).should eq "tcp://127.0.0.2:9399"
+        allow(service_directory).to receive(:all_listings_for).and_return(listings)
+        expect(subject.send(:lookup_server_uri)).to eq "tcp://127.0.0.2:9399"
       end
 
       it "defaults to the options" do
-        service_directory.stub(:all_listings_for).and_return([])
-        subject.send(:lookup_server_uri).should eq "tcp://127.0.0.1:9400"
+        allow(service_directory).to receive(:all_listings_for).and_return([])
+        expect(subject.send(:lookup_server_uri)).to eq "tcp://127.0.0.1:9400"
       end
     end
 
@@ -62,21 +51,21 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
       let(:running?) { false }
 
       it "defaults to the options" do
-        service_directory.stub(:all_listings_for).and_return([])
-        subject.send(:lookup_server_uri).should eq "tcp://127.0.0.1:9400"
+        allow(service_directory).to receive(:all_listings_for).and_return([])
+        expect(subject.send(:lookup_server_uri)).to eq "tcp://127.0.0.1:9400"
       end
     end
 
     it "checks if the server is alive" do
-      service_directory.stub(:all_listings_for).and_return([])
-      subject.should_receive(:host_alive?).with("127.0.0.1") { true }
-      subject.send(:lookup_server_uri).should eq "tcp://127.0.0.1:9400"
+      allow(service_directory).to receive(:all_listings_for).and_return([])
+      expect(subject).to receive(:host_alive?).with("127.0.0.1") { true }
+      expect(subject.send(:lookup_server_uri)).to eq "tcp://127.0.0.1:9400"
     end
 
     context "when no host is alive" do
       it "raises an error" do
-        service_directory.stub(:all_listings_for).and_return(listings)
-        subject.stub(:host_alive?).and_return(false)
+        allow(service_directory).to receive(:all_listings_for).and_return(listings)
+        allow(subject).to receive(:host_alive?).and_return(false)
         expect { subject.send(:lookup_server_uri) }.to raise_error
       end
     end
@@ -90,11 +79,11 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
       end
 
       it "returns true" do
-        subject.send(:host_alive?, "yip.yip").should be_true
+        expect(subject.send(:host_alive?, "yip.yip")).to be_truthy
       end
 
       it "does not attempt a connection" do
-        TCPSocket.should_not_receive(:new)
+        expect(TCPSocket).not_to receive(:new)
         subject.send(:host_alive?, "blargh.com")
       end
     end
@@ -105,20 +94,20 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
       end
 
       it "returns true when the connection succeeds" do
-        TCPSocket.should_receive(:new).with("huzzah.com", 3307) { double(:close => nil) }
-        subject.send(:host_alive?, "huzzah.com").should be_true
+        expect(TCPSocket).to receive(:new).with("huzzah.com", 3307).and_return(double(:close => nil))
+        expect(subject.send(:host_alive?, "huzzah.com")).to be_truthy
       end
 
       it "returns false when the connection fails" do
-        TCPSocket.should_receive(:new).with("hayoob.com", 3307).and_raise(Errno::ECONNREFUSED)
-        subject.send(:host_alive?, "hayoob.com").should be_false
+        expect(TCPSocket).to receive(:new).with("hayoob.com", 3307).and_raise(Errno::ECONNREFUSED)
+        expect(subject.send(:host_alive?, "hayoob.com")).to be_falsey
       end
 
       it "closes the socket" do
         socket = double("TCPSocket")
-        socket.should_receive(:close)
-        TCPSocket.should_receive(:new).with("absorbalof.com", 3307) { socket }
-        subject.send(:host_alive?, "absorbalof.com").should be_true
+        expect(socket).to receive(:close)
+        expect(TCPSocket).to receive(:new).with("absorbalof.com", 3307).and_return(socket)
+        expect(subject.send(:host_alive?, "absorbalof.com")).to be_truthy
       end
     end
   end

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

@@ -8,19 +8,19 @@ describe Protobuf::Rpc::Middleware::ExceptionHandler do
 
   describe "#call" do
     it "calls the stack" do
-      app.should_receive(:call).with(env)
+      expect(app).to receive(:call).with(env)
       subject.call(env)
     end
 
     it "returns the env" do
-      subject.call(env).should eq env
+      expect(subject.call(env)).to eq env
     end
 
     context "when exceptions occur" do
       let(:encoded_error) { error.encode }
       let(:error) { Protobuf::Rpc::MethodNotFound.new('Boom!') }
 
-      before { app.stub(:call).and_raise(error, 'Boom!') }
+      before { allow(app).to receive(:call).and_raise(error, 'Boom!') }
 
       it "rescues exceptions" do
         expect { subject.call(env) }.not_to raise_exception
@@ -32,12 +32,12 @@ describe Protobuf::Rpc::Middleware::ExceptionHandler do
 
           # Can't compare the error instances because the response has been
           # raised and thus has a backtrace while the error does not.
-          stack_env.response.class.should eq error.class
+          expect(stack_env.response.class).to eq error.class
         end
 
         it "encodes the response" do
           stack_env = subject.call(env)
-          stack_env.encoded_response.should eq encoded_error
+          expect(stack_env.encoded_response).to eq encoded_error
         end
       end
 
@@ -45,16 +45,16 @@ describe Protobuf::Rpc::Middleware::ExceptionHandler do
         let(:encoded_error) { error.encode }
         let(:error) { Protobuf::Rpc::RpcFailed.new('Boom!') }
 
-        before { app.stub(:call).and_raise(RuntimeError, 'Boom!') }
+        before { allow(app).to receive(:call).and_raise(RuntimeError, 'Boom!') }
 
         it "wraps the exception in a generic Protobuf error" do
           stack_env = subject.call(env)
-          stack_env.response.should eq error
+          expect(stack_env.response).to eq error
         end
 
         it "encodes the wrapped exception" do
           stack_env = subject.call(env)
-          stack_env.encoded_response.should eq encoded_error
+          expect(stack_env.encoded_response).to eq encoded_error
         end
       end
     end

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

@@ -38,12 +38,12 @@ describe Protobuf::Rpc::Middleware::Logger do
 
   describe "#call" do
     it "calls the stack" do
-      app.should_receive(:call).with(env)
+      expect(app).to receive(:call).with(env).and_return(env)
       subject.call(env)
     end
 
     it "returns the env" do
-      subject.call(env).should eq env
+      expect(subject.call(env)).to eq env
     end
   end
 end

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

@@ -31,51 +31,51 @@ describe Protobuf::Rpc::Middleware::RequestDecoder do
   describe "#call" do
     it "decodes the request" do
       stack_env = subject.call(env)
-      stack_env.request.should eq request
+      expect(stack_env.request).to eq request
     end
 
     it "calls the stack" do
-      app.should_receive(:call).with(env)
+      expect(app).to receive(:call).with(env)
       subject.call(env)
     end
 
     it "sets Env#client_host" do
       stack_env = subject.call(env)
-      stack_env.client_host.should eq client_host
+      expect(stack_env.client_host).to eq client_host
     end
 
     it "sets Env#service_name" do
       stack_env = subject.call(env)
-      stack_env.service_name.should eq service_name
+      expect(stack_env.service_name).to eq service_name
     end
 
     it "sets Env#method_name" do
       stack_env = subject.call(env)
-      stack_env.method_name.should eq method_name.to_sym
+      expect(stack_env.method_name).to eq method_name.to_sym
     end
 
     it "sets Env#request_type" do
       stack_env = subject.call(env)
-      stack_env.request_type.should eq request_type
+      expect(stack_env.request_type).to eq request_type
     end
 
     it "sets Env#response_type" do
       stack_env = subject.call(env)
-      stack_env.response_type.should eq response_type
+      expect(stack_env.response_type).to eq response_type
     end
 
     it "sets Env#rpc_method" do
       stack_env = subject.call(env)
-      stack_env.rpc_method.should eq rpc_method
+      expect(stack_env.rpc_method).to eq rpc_method
     end
 
     it "sets Env#rpc_service" do
       stack_env = subject.call(env)
-      stack_env.rpc_service.should eq rpc_service
+      expect(stack_env.rpc_service).to eq rpc_service
     end
 
     context "when decoding fails" do
-      before { Protobuf::Socketrpc::Request.stub(:decode).and_raise(RuntimeError) }
+      before { allow(Protobuf::Socketrpc::Request).to receive(:decode).and_raise(RuntimeError) }
 
       it "raises a bad request data exception" do
         expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::BadRequestData)