protobuffy 3.6.0 → 4.0.0

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

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
 shared_examples "a Protobuf Connector" do
-  subject{ described_class.new({}) }
+  subject { described_class.new({}) }
 
   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 { subject.respond_to?(:send_request, true).should be true }
+    specify { subject.respond_to?(:close_connection, true).should be true }
+    specify { subject.respond_to?(:error?, true).should be true }
   end
 end

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

@@ -4,21 +4,23 @@ require 'faraday'
 
 describe ::Protobuf::Rpc::Connectors::Http do
   subject { described_class.new({}) }
-  
-  it_behaves_like "a Protobuf Connector"
 
-  specify{ described_class.include?(Protobuf::Rpc::Connectors::Common).should be_true }
+  it_behaves_like "a Protobuf Connector"
+  specify { subject.respond_to?(:post_init, true).should be true }
 
   let(:client_double) do
     Faraday.new do |builder|
       builder.adapter :test do |stub|
-        stub.post("/Foo/UserService/find") {[ 200, {}, "\n\n\n\x03foo\x12\x03bar" ]}
-        stub.post("/Foo/UserService/foo1") {[ 404, {
-          'x-protobuf-error' => "Foo::UserService#foo1 is not a defined RPC method.",
-          'x-protobuf-error-reason' => Protobuf::Socketrpc::ErrorReason::METHOD_NOT_FOUND.to_s
-        }, "" ]}
-        stub.post("/Foo/UserService/foo2") {[ 500, {}, "" ]}
-        stub.post("/base/Foo/UserService/foo3") {[ 200, {}, "\n\n\n\x03foo\x12\x03bar" ]}
+        stub.post("/Foo/UserService/find") { [200, {}, "\n\n\n\x03foo\x12\x03bar"] }
+        stub.post("/Foo/UserService/foo1") do
+          headers = {
+            'x-protobuf-error' => "Foo::UserService#foo1 is not a defined RPC method.",
+            'x-protobuf-error-reason' => Protobuf::Socketrpc::ErrorReason::METHOD_NOT_FOUND.to_s,
+          }
+          [404, headers, '']
+        end
+        stub.post("/Foo/UserService/foo2") { [500, {}, ""] }
+        stub.post("/base/Foo/UserService/foo3") { [200, {}, "\n\n\n\x03foo\x12\x03bar"] }
       end
     end
   end
@@ -51,7 +53,7 @@ describe ::Protobuf::Rpc::Connectors::Http do
     end
 
     it "prepends base path option correctly" do
-      subject.stub(:options) { { :base => "/base" }}
+      subject.stub(:options) { { :base => "/base" } }
       subject.stub(:request_bytes) { "\n\x10Foo::UserService\x12\x04foo3\x1A\r\n\vfoo@bar.com\"\rabcdefghijklm" }
       subject.send(:setup_connection)
       subject.send(:send_data)

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

@@ -0,0 +1,69 @@
+require "spec_helper"
+require "protobuf/zmq"
+
+::RSpec.describe ::Protobuf::Rpc::Connectors::Ping do
+  subject { described_class.new("google.com", 80) }
+
+  let(:host) { "google.com" }
+  let(:port) { 80 }
+
+  describe ".new" do
+    it "assigns host" do
+      expect(subject.host).to eq(host)
+    end
+
+    it "assigns port" do
+      expect(subject.port).to eq(port)
+    end
+  end
+
+  describe "#online?" do
+    it "closes the socket" do
+      socket = double(:close => nil, :setsockopt => nil)
+      allow(subject).to receive(:tcp_socket).and_return(socket)
+      expect(socket).to receive(:close)
+      expect(subject).to be_online
+    end
+
+    context "when a socket can connect" do
+      let(:socket) { double(:close => nil, :setsockopt => nil) }
+      before { allow(subject).to receive(:tcp_socket).and_return(socket) }
+
+      it "returns true" do
+        expect(subject).to be_online
+      end
+    end
+
+    context "when a socket error is raised" do
+      before { allow(subject).to receive(:tcp_socket).and_raise(::Errno::ECONNREFUSED) }
+
+      it "returns false" do
+        expect(subject).to_not be_online
+      end
+    end
+
+    context "when a select timeout is fired" do
+      let(:wait_writable_class) { ::Class.new(StandardError) { include ::IO::WaitWritable } }
+      before { expect_any_instance_of(::Socket).to receive(:connect_nonblock).and_raise(wait_writable_class) }
+
+      it "returns false" do
+        expect(::IO).to receive(:select).and_return(false)
+        expect(subject).to_not be_online
+      end
+    end
+  end
+
+  describe "#timeout" do
+    it "uses the default value" do
+      expect(subject.timeout).to eq(0.2)
+    end
+
+    context "when environment variable is set" do
+      before { ::ENV["PB_RPC_PING_PORT_TIMEOUT"] = "100" }
+
+      it "uses the environmet variable" do
+        expect(subject.timeout).to eq(0.1)
+      end
+    end
+  end
+end

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

@@ -1,24 +1,23 @@
 require 'spec_helper'
 require 'protobuf/socket'
 
-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"
-
-  specify{ described_class.include?(Protobuf::Rpc::Connectors::Common).should be_true }
+  specify { subject.respond_to?(:post_init, true).should be true }
 
   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

@@ -1,35 +1,27 @@
 require 'spec_helper'
 require 'protobuf/zmq'
 
-describe ::Protobuf::Rpc::Connectors::Zmq do
+RSpec.describe ::Protobuf::Rpc::Connectors::Zmq do
   subject { described_class.new(options) }
-  
-  it_behaves_like "a Protobuf Connector"
-
-  specify{ described_class.include?(Protobuf::Rpc::Connectors::Common).should be_true }
 
-  let(:options) {{
-    :service => "Test::Service",
-    :method => "find",
-    :timeout => 3,
-    :host => "127.0.0.1",
-    :port => "9400"
-  }}
+  it_behaves_like "a Protobuf Connector"
 
-  let(:socket_double) do
-    sm = double(::ZMQ::Socket)
-    sm.stub(:connect).and_return(0)
-    sm
+  let(:options) do
+    {
+      :service => "Test::Service",
+      :method => "find",
+      :timeout => 3,
+      :host => "127.0.0.1",
+      :port => "9400",
+    }
   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)
+    allow(socket_double).to receive(:setsockopt)
   end
 
   before(:all) do
@@ -41,24 +33,22 @@ 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 }
 
-    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
 
@@ -66,22 +56,22 @@ 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)
-        expect { subject.send(:lookup_server_uri) }.to raise_error
+        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(RuntimeError)
       end
     end
 
@@ -94,35 +84,28 @@ 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 true
       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
 
     context "when the PB_RPC_PING_PORT is set" do
       before do
-        ENV["PB_RPC_PING_PORT"] = "3307"
+        ::ENV["PB_RPC_PING_PORT"] = "3307"
       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
+        allow_any_instance_of(::Protobuf::Rpc::Connectors::Ping).to receive(:online?).and_return(true)
+        expect(subject.send(:host_alive?, "huzzah1.com")).to eq(true)
       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
-      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
+        allow_any_instance_of(::Protobuf::Rpc::Connectors::Ping).to receive(:online?).and_return(false)
+        expect(subject.send(:host_alive?, "huzzah2.com")).to eq(false)
       end
     end
   end

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

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

@@ -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,
@@ -14,20 +14,20 @@ describe Protobuf::Rpc::Middleware::Logger 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) {
-    Protobuf::Socketrpc::Request.new(
+  let(:request_wrapper) do
+    ::Protobuf::Socketrpc::Request.new(
       :service_name => service_name,
       :method_name => method_name.to_s,
       :request_proto => request
     )
-  }
-  let(:response_wrapper) { Protobuf::Socketrpc::Response.new(:response_proto => response) }
+  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] }
   let(:rpc_service) { service_class.new(env) }
@@ -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

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