prepor-protobuf 3.5.0

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

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+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
+      expect(app).to receive(:call).with(env)
+      subject.call(env)
+    end
+
+    it "returns the env" do
+      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 { allow(app).to receive(:call).and_raise(error, 'Boom!') }
+
+      it "rescues exceptions" do
+        expect { subject.call(env) }.not_to raise_exception
+      end
+
+      context "when exception is a Protobuf error" do
+        it "does not wrap the exception in a generic Protobuf error" do
+          stack_env = subject.call(env)
+
+          # Can't compare the error instances because the response has been
+          # raised and thus has a backtrace while the error does not.
+          expect(stack_env.response.class).to eq error.class
+        end
+
+        it "encodes the response" do
+          stack_env = subject.call(env)
+          expect(stack_env.encoded_response).to eq encoded_error
+        end
+      end
+
+      context "when exception is not a Protobuf error" do
+        let(:encoded_error) { error.encode }
+        let(:error) { Protobuf::Rpc::RpcFailed.new('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)
+          expect(stack_env.response).to eq error
+        end
+
+        it "encodes the wrapped exception" do
+          stack_env = subject.call(env)
+          expect(stack_env.encoded_response).to eq encoded_error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+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,
+      'encoded_response' => response_wrapper.encode,
+      'method_name' => method_name,
+      'request' => request,
+      'request_type' => rpc_method.request_type,
+      'response' => response,
+      'response_type' => rpc_method.response_type,
+      'rpc_method' => rpc_method,
+      '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) do
+    Protobuf::Socketrpc::Request.new(
+      :service_name => service_name,
+      :method_name => method_name.to_s,
+      :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] }
+  let(:rpc_service) { service_class.new(env) }
+  let(:service_class) { Test::ResourceService }
+  let(:service_name) { service_class.to_s }
+
+  subject { described_class.new(app) }
+
+  describe "#call" do
+    it "calls the stack" do
+      expect(app).to receive(:call).with(env).and_return(env)
+      subject.call(env)
+    end
+
+    it "returns the env" do
+      expect(subject.call(env)).to eq env
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+RSpec.describe Protobuf::Rpc::Middleware::RequestDecoder do
+  let(:app) { proc { |env| env } }
+  let(:client_host) { 'client_host.test.co' }
+  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) 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 }
+  let(:service_name) { rpc_service.to_s }
+
+  subject { described_class.new(app) }
+
+  describe "#call" do
+    it "decodes the request" do
+      stack_env = subject.call(env)
+      expect(stack_env.request).to eq request
+    end
+
+    it "calls the stack" do
+      expect(app).to receive(:call).with(env)
+      subject.call(env)
+    end
+
+    it "sets Env#client_host" do
+      stack_env = subject.call(env)
+      expect(stack_env.client_host).to eq client_host
+    end
+
+    it "sets Env#service_name" do
+      stack_env = subject.call(env)
+      expect(stack_env.service_name).to eq service_name
+    end
+
+    it "sets Env#method_name" do
+      stack_env = subject.call(env)
+      expect(stack_env.method_name).to eq method_name.to_sym
+    end
+
+    it "sets Env#request_type" do
+      stack_env = subject.call(env)
+      expect(stack_env.request_type).to eq request_type
+    end
+
+    it "sets Env#response_type" do
+      stack_env = subject.call(env)
+      expect(stack_env.response_type).to eq response_type
+    end
+
+    it "sets Env#rpc_method" do
+      stack_env = subject.call(env)
+      expect(stack_env.rpc_method).to eq rpc_method
+    end
+
+    it "sets Env#rpc_service" do
+      stack_env = subject.call(env)
+      expect(stack_env.rpc_service).to eq rpc_service
+    end
+
+    context "when decoding fails" do
+      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)
+      end
+    end
+
+    context "when the RPC service is not defined" do
+      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)
+      end
+    end
+
+    context "when RPC method is not defined" do
+      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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+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) }
+
+  subject { described_class.new(app) }
+
+  describe "#call" do
+    it "encodes the response" do
+      stack_env = subject.call(env)
+      expect(stack_env.encoded_response).to eq encoded_response
+    end
+
+    it "calls the stack" do
+      stack_env = subject.call(env)
+      expect(stack_env.response).to eq response
+    end
+
+    context "when response is responds to :to_hash" do
+      let(:app) { proc { |env| env.response = hashable; env } }
+      let(:hashable) { double('hashable', :to_hash => response.to_hash) }
+
+      it "sets Env#response" do
+        stack_env = subject.call(env)
+        expect(stack_env.response).to eq response
+      end
+    end
+
+    context "when response is responds to :to_proto" do
+      let(:app) { proc { |env| env.response = protoable; env } }
+      let(:protoable) { double('protoable', :to_proto => response) }
+
+      it "sets Env#response" do
+        stack_env = subject.call(env)
+        expect(stack_env.response).to eq response
+      end
+    end
+
+    context "when response is not a valid response type" do
+      let(:app) { proc { |env| env.response = "I'm not a valid response"; env } }
+
+      it "raises a bad response proto exception" do
+        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::BadResponseProto)
+      end
+    end
+
+    context "when response is a Protobuf error" do
+      let(:app) { proc { |env| env.response = error; env } }
+      let(:error) { Protobuf::Rpc::RpcError.new }
+      let(:response_wrapper) { error.to_response }
+
+      it "wraps and encodes the response" do
+        stack_env = subject.call(env)
+        expect(stack_env.encoded_response).to eq encoded_response
+      end
+    end
+
+    context "when encoding fails" do
+      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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+require 'protobuf/rpc/servers/socket_runner'
+require 'protobuf/socket'
+
+RSpec.describe Protobuf::Rpc::Socket::Server do
+  before(:each) do
+    load 'protobuf/socket.rb'
+  end
+
+  before(:all) do
+    load 'protobuf/socket.rb'
+    Thread.abort_on_exception = true
+    @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 }
+    Thread.pass until @server.running?
+  end
+
+  after(:all) do
+    @server.stop
+    @server_thread.join
+  end
+
+  it "Runner provides a stop method" do
+    expect(@runner).to respond_to(:stop)
+  end
+
+  it "provides a stop method" do
+    expect(@server).to respond_to(:stop)
+  end
+
+  it "signals the Server is running" do
+    expect(@server).to be_running
+  end
+
+end

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

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

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+class UtilTest
+  include ::Protobuf::Rpc::Zmq::Util
+end
+
+RSpec.describe ::Protobuf::Rpc::Zmq::Util do
+  before(:each) do
+    load 'protobuf/zmq.rb'
+  end
+
+  subject { UtilTest.new }
+  describe '#zmq_error_check' do
+    it 'raises when the error code is less than 0' do
+      expect do
+        subject.zmq_error_check(-1, :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 do
+        subject.zmq_error_check(-1, :test)
+      end.to raise_error(RuntimeError, /an error from zmq/i)
+    end
+
+    it 'does nothing if the error code is > 0' do
+      expect do
+        subject.zmq_error_check(1, :test)
+      end.to_not raise_error
+    end
+
+    it 'does nothing if the error code is == 0' do
+      expect do
+        subject.zmq_error_check(0, :test)
+      end.to_not raise_error
+    end
+  end
+
+  describe '#log_signature' do
+    it 'returns the signature for the log' do
+      expect(subject.log_signature).to include('server', 'UtilTest')
+    end
+  end
+
+  describe '.resolve_ip' do
+    it 'resolves ips' do
+      expect(subject.resolve_ip('127.0.0.1')).to eq('127.0.0.1')
+    end
+
+    it 'resolves non ips' do
+      expect(subject.resolve_ip('localhost')).to eq('127.0.0.1')
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+RSpec.describe ::Protobuf::Rpc::Zmq::Worker do
+  before(:each) do
+    load 'protobuf/zmq.rb'
+
+    fake_socket = double
+    expect(fake_socket).to receive(:connect).and_return(0)
+    expect(fake_socket).to receive(:send_string).and_return(0)
+
+    fake_context = double
+    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)
+  end
+
+  describe '#run' do
+    # not tested via unit tests
+  end
+
+  describe '#handle_request' do
+    # not tested via unit tests
+  end
+
+  describe '#initialize_buffers' do
+    # not tested via unit tests
+  end
+
+  describe '#send_data' do
+    # not tested via unit tests
+  end
+end