protobuf 3.3.6 → 3.4.0

data/spec/lib/protobuf/optionable_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'protobuf/optionable'
 
-describe 'Optionable' do
+RSpec.describe 'Optionable' do
 
   describe '.set_option' do
     before(:all) do
@@ -13,9 +13,9 @@ describe 'Optionable' do
     it 'stores the given option and value' do
       expect(OptionableSetOptionTest).to respond_to(:set_option)
       expect(OptionableSetOptionTest.method(:set_option).arity).to eq(-2)
-      expect {
+      expect do
         OptionableSetOptionTest.set_option(:foo, :bar)
-      }.to_not raise_error
+      end.to_not raise_error
     end
 
     it 'defaults the value to true' do

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'spec/support/test/resource_service'
 
-describe Protobuf::Rpc::Client do
+RSpec.describe Protobuf::Rpc::Client do
   before(:each) do
     load 'protobuf/socket.rb'
   end
@@ -55,7 +55,7 @@ describe Protobuf::Rpc::Client do
     it 'should be able to create the correct request object if passed a hash' do
       client = Test::ResourceService.client
       expect(client).to receive(:send_request)
-      client.find({:name => 'Test Name', :active => false})
+      client.find(:name => 'Test Name', :active => 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)

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'protobuf/socket'
 require 'protobuf/zmq'
 
-describe ::Protobuf::Rpc::Connector do
+RSpec.describe ::Protobuf::Rpc::Connector do
 
   describe '.connector_for_client(true)' do
     subject { described_class.connector_for_client }

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Protobuf::Rpc::Connectors::Base do
+RSpec.describe Protobuf::Rpc::Connectors::Base do
 
   let(:options) do
     { :timeout => 60 }
@@ -10,12 +10,12 @@ describe Protobuf::Rpc::Connectors::Base do
 
   describe "#send_request" do
     it "raising an error when 'send_request' is not overridden" do
-      expect{ subject.send_request }.to raise_error(RuntimeError, /inherit a Connector/)
+      expect { subject.send_request }.to raise_error(RuntimeError, /inherit a Connector/)
     end
 
     it "does not raise error when 'send_request' is overridden" do
-      new_sub = Class.new(subject.class){ def send_request; end }.new(options)
-      expect{ new_sub.send_request }.to_not raise_error
+      new_sub = Class.new(subject.class) { def send_request; end }.new(options)
+      expect { new_sub.send_request }.to_not raise_error
     end
   end
 
@@ -30,7 +30,7 @@ describe Protobuf::Rpc::Connectors::Base do
   describe '#success_cb' do
     it 'allows setting the success callback and calling it' do
       expect(subject.success_cb).to be_nil
-      cb = proc {|res| raise res }
+      cb = proc { |res| fail res }
       subject.success_cb = cb
       expect(subject.success_cb).to eq(cb)
       expect { subject.success_cb.call('an error from cb') }.to raise_error 'an error from cb'
@@ -40,7 +40,7 @@ describe Protobuf::Rpc::Connectors::Base do
   describe '#failure_cb' do
     it 'allows setting the failure callback and calling it' do
       expect(subject.failure_cb).to be_nil
-      cb = proc {|res| raise res }
+      cb = proc { |res| fail res }
       subject.failure_cb = cb
       expect(subject.failure_cb).to eq(cb)
       expect { subject.failure_cb.call('an error from cb') }.to raise_error 'an error from cb'

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'protobuf/rpc/service'
 
-describe Protobuf::Rpc::Connectors::Common do
+RSpec.describe Protobuf::Rpc::Connectors::Common do
   let(:common_class) do
     Class.new(Protobuf::Rpc::Connectors::Base) do
       include Protobuf::Rpc::Connectors::Common
@@ -19,7 +19,7 @@ describe Protobuf::Rpc::Connectors::Common do
     specify { expect(subject.respond_to?(:request_caller)).to be true }
     specify { expect(subject.respond_to?(:data_callback)).to be true }
     specify { expect(subject.respond_to?(:error)).to be true }
-    specify { expect(subject.respond_to?(:fail)).to be true }
+    specify { expect(subject.respond_to?(:failure)).to be true }
     specify { expect(subject.respond_to?(:complete)).to be true }
     specify { expect(subject.respond_to?(:parse_response)).to be true }
     specify { expect(subject.respond_to?(:verify_options!)).to be true }
@@ -74,18 +74,26 @@ describe Protobuf::Rpc::Connectors::Common do
     let(:method) { :find }
     let(:request) { '' }
     let(:client_host) { 'myhost.myservice.com' }
-    let(:subject_options) { { :service => service,
-                              :method => method,
-                              :request => request,
-                              :client_host => client_host } }
+    let(:subject_options) do
+      {
+        :service => service,
+        :method => method,
+        :request => request,
+        :client_host => client_host,
+      }
+    end
 
-    let(:expected) { ::Protobuf::Socketrpc::Request.new({ :service_name => service.name,
-                                                          :method_name => 'find',
-                                                          :request_proto => '',
-                                                          :caller => client_host }) }
+    let(:expected) do
+      ::Protobuf::Socketrpc::Request.new(
+        :service_name => service.name,
+        :method_name => 'find',
+        :request_proto => '',
+        :caller => client_host,
+      )
+    end
 
     before { allow(subject).to receive(:validate_request_type!).and_return(true) }
-    before { expect(subject).not_to receive(:fail) }
+    before { expect(subject).not_to receive(:failure) }
 
     specify { expect(subject.request_bytes).to eq expected.encode }
   end
@@ -103,7 +111,7 @@ describe Protobuf::Rpc::Connectors::Common do
     end
 
     it "doesn't set @failure_cb when already defined" do
-      set_cb = lambda{ true }
+      set_cb = -> { true }
       subject.instance_variable_set(:@failure_cb, set_cb)
       subject.verify_callbacks
       expect(subject.instance_variable_get(:@failure_cb)).to eq(set_cb)
@@ -111,7 +119,7 @@ describe Protobuf::Rpc::Connectors::Common do
     end
 
     it "doesn't set @success_cb when already defined" do
-      set_cb = lambda{ true }
+      set_cb = -> { true }
       subject.instance_variable_set(:@success_cb, set_cb)
       subject.verify_callbacks
       expect(subject.instance_variable_get(:@success_cb)).to eq(set_cb)
@@ -133,10 +141,10 @@ describe Protobuf::Rpc::Connectors::Common do
       stats = double("Object")
       allow(stats).to receive(:stop).and_return(true)
       subject.stats = stats
-      _cb = double("Object")
+      some_cb = double("Object")
 
-      subject.instance_variable_set("@#{cb}", _cb)
-      expect(_cb).to receive(:call).and_return(true)
+      subject.instance_variable_set("@#{cb}", some_cb)
+      expect(some_cb).to receive(:call).and_return(true)
       subject.method(meth).call(*args)
     end
 
@@ -153,8 +161,8 @@ describe Protobuf::Rpc::Connectors::Common do
 
   end
 
-  it_behaves_like("a ConnectorDisposition", :fail, "failure_cb", "code", "message")
-  it_behaves_like("a ConnectorDisposition", :fail, "complete_cb", "code", "message")
+  it_behaves_like("a ConnectorDisposition", :failure, "failure_cb", "code", "message")
+  it_behaves_like("a ConnectorDisposition", :failure, "complete_cb", "code", "message")
   it_behaves_like("a ConnectorDisposition", :succeed, "complete_cb", "response")
   it_behaves_like("a ConnectorDisposition", :succeed, "success_cb", "response")
   it_behaves_like("a ConnectorDisposition", :complete, "complete_cb")

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

@@ -1,8 +1,8 @@
 require 'spec_helper'
 require 'protobuf/socket'
 
-shared_examples "a Protobuf Connector" do
-  subject{ described_class.new({}) }
+RSpec.shared_examples "a Protobuf Connector" do
+  subject { described_class.new({}) }
 
   context "API" do
     # Check the API
@@ -13,8 +13,8 @@ shared_examples "a Protobuf Connector" do
   end
 end
 
-describe Protobuf::Rpc::Connectors::Socket do
-  subject{ described_class.new({}) }
+RSpec.describe Protobuf::Rpc::Connectors::Socket do
+  subject { described_class.new({}) }
 
   it_behaves_like "a Protobuf Connector"
 

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

@@ -1,16 +1,18 @@
 require 'spec_helper'
 require 'protobuf/zmq'
 
-describe ::Protobuf::Rpc::Connectors::Zmq do
+RSpec.describe ::Protobuf::Rpc::Connectors::Zmq do
   subject { described_class.new(options) }
 
-  let(:options) {{
-    :service => "Test::Service",
-    :method => "find",
-    :timeout => 3,
-    :host => "127.0.0.1",
-    :port => "9400"
-  }}
+  let(:options) do
+    {
+      :service => "Test::Service",
+      :method => "find",
+      :timeout => 3,
+      :host => "127.0.0.1",
+      :port => "9400",
+    }
+  end
 
   let(:socket_double) { double(::ZMQ::Socket, :connect => 0) }
   let(:zmq_context_double) { double(::ZMQ::Context, :socket => socket_double) }
@@ -29,7 +31,7 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
   end
 
   describe "#lookup_server_uri" do
-    let(:service_directory) { double('ServiceDirectory', :running? => running? ) }
+    let(:service_directory) { double('ServiceDirectory', :running? => running?) }
     let(:listing) { double('Listing', :address => '127.0.0.2', :port => 9399) }
     let(:listings) { [listing] }
     let(:running?) { true }

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Protobuf::Rpc::Middleware::ExceptionHandler do
-  let(:app) { Proc.new { |env| env } }
+RSpec.describe Protobuf::Rpc::Middleware::ExceptionHandler do
+  let(:app) { proc { |env| env } }
   let(:env) { Protobuf::Rpc::Env.new }
 
   subject { described_class.new(app) }

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

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Protobuf::Rpc::Middleware::Logger do
-  let(:app) { Proc.new { |inner_env| inner_env } }
-  let(:env) {
+RSpec.describe Protobuf::Rpc::Middleware::Logger do
+  let(:app) { proc { |inner_env| inner_env } }
+  let(:env) do
     Protobuf::Rpc::Env.new(
       'client_host' => 'client_host.test.co',
       'encoded_request' => request_wrapper.encode,
@@ -16,17 +16,17 @@ describe Protobuf::Rpc::Middleware::Logger do
       'rpc_service' => service_class,
       '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
+      :request_proto => request,
     )
-  }
+  end
   let(:response_wrapper) { Protobuf::Socketrpc::Response.new(:response_proto => response) }
   let(:response) { rpc_method.response_type.new(:name => 'required') }
   let(:rpc_method) { service_class.rpcs[method_name] }

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

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
-describe Protobuf::Rpc::Middleware::RequestDecoder do
-  let(:app) { Proc.new { |env| env } }
+RSpec.describe Protobuf::Rpc::Middleware::RequestDecoder do
+  let(:app) { proc { |env| env } }
   let(:client_host) { 'client_host.test.co' }
-  let(:env) {
+  let(:env) do
     Protobuf::Rpc::Env.new(
       'encoded_request' => encoded_request,
-      'log_signature' => 'log_signature'
+      'log_signature' => 'log_signature',
     )
-  }
+  end
   let(:encoded_request) { request_wrapper.encode }
   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(
       :caller => client_host,
       :service_name => service_name,
       :method_name => method_name.to_s,
-      :request_proto => request
+      :request_proto => request,
     )
-  }
+  end
   let(:response_type) { rpc_method.response_type }
   let(:rpc_method) { rpc_service.rpcs[method_name] }
   let(:rpc_service) { Test::ResourceService }
@@ -83,14 +83,14 @@ describe Protobuf::Rpc::Middleware::RequestDecoder do
     end
 
     context "when the RPC service is not defined" do
-      let(:request_wrapper) {
+      let(:request_wrapper) do
         Protobuf::Socketrpc::Request.new(
           :caller => client_host,
           :service_name => 'Foo',
           :method_name => method_name.to_s,
-          :request_proto => request
+          :request_proto => request,
         )
-      }
+      end
 
       it "raises a bad request data exception" do
         expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::ServiceNotFound)
@@ -98,14 +98,14 @@ describe Protobuf::Rpc::Middleware::RequestDecoder do
     end
 
     context "when RPC method is not defined" do
-      let(:request_wrapper) {
+      let(:request_wrapper) do
         Protobuf::Socketrpc::Request.new(
           :caller => client_host,
           :service_name => service_name,
           :method_name => 'foo',
-          :request_proto => request
+          :request_proto => request,
         )
-      }
+      end
 
       it "raises a bad request data exception" do
         expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::MethodNotFound)

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

@@ -1,13 +1,13 @@
 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'
+      '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) }

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

@@ -3,7 +3,7 @@ require 'spec/support/test/resource_service'
 require 'protobuf/rpc/servers/socket_runner'
 require 'protobuf/socket'
 
-describe Protobuf::Rpc::Socket::Server do
+RSpec.describe Protobuf::Rpc::Socket::Server do
   before(:each) do
     load 'protobuf/socket.rb'
   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'

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,28 +12,28 @@ 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
       allow(ZMQ::Util).to receive(:error_string).and_return('an error from zmq')
-      expect {
+      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