protobuf 2.2.5-java

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'spec/support/test/resource_service'
+require 'protobuf/rpc/servers/socket_runner'
+require 'protobuf/evented'
+require 'protobuf/socket'
+
+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
+    server = OpenStruct.new(:server => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
+    @server_thread = Thread.new(server) { |s| Protobuf::Rpc::SocketRunner.run(s) }
+    Thread.pass until Protobuf::Rpc::Socket::Server.running?
+  end
+
+  after(:all) do
+    Protobuf::Rpc::SocketRunner.stop
+    @server_thread.join
+  end
+
+  it "Runner provides a stop method" do
+    runner_class = described_class.to_s.gsub(/Evented::Server/, "EventedRunner").constantize
+    runner_class.respond_to?(:stop).should be_true
+  end
+
+  it "provides a stop method" do
+    described_class.respond_to?(:stop).should be_true
+  end
+
+  it "provides a Runner class" do
+    runner_class = described_class.to_s.gsub(/Evented::Server/, "EventedRunner")
+    expect { runner_class.constantize }.to_not raise_error
+  end
+
+  it "signals the Server is running" do
+    described_class.running?.should be_true
+  end
+
+end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe ::Protobuf::Rpc::Zmq::Broker do
+  before(:each) do
+    load 'protobuf/zmq.rb'
+  end
+
+  after(:each) do
+    subject.teardown
+  end
+
+  subject do
+    described_class.new({ :host => '127.0.0.1', :port => 9399 })
+  end
+
+  it 'sets up a context' do
+    subject.context.should be_a(::ZMQ::Context)
+  end
+
+  it 'sets up a frontend socket' do
+    subject.frontend.should be_a(::ZMQ::Socket)
+  end
+
+  it 'sets up a backend socket' do
+    subject.backend.should be_a(::ZMQ::Socket)
+  end
+
+  it 'sets up a polling object' do
+    subject.poller.should be_a(::ZMQ::Poller)
+  end
+
+  describe '#poll' do
+    # no unit tests for this method
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'protobuf/rpc/servers/zmq/server'
+
+describe Protobuf::Rpc::Zmq::Server do
+  before(:each) do 
+    load 'protobuf/zmq.rb'
+  end
+
+  describe '.running?' do
+    it 'returns true if running' do
+      described_class.instance_variable_set(:@running, true)
+      described_class.running?.should be_true
+    end
+
+    it 'returns false if not running' do
+      described_class.instance_variable_set(:@running, false)
+      described_class.running?.should be_false
+    end
+  end
+
+  describe '.stop' do
+    # keep threads instance variable from retaining any thread mocks we've
+    # created (breaks tests down the line, otherwise)
+    after(:each) do
+      described_class.instance_variable_set(:@threads, [])
+    end
+
+    it 'lets all threads stop' do
+      thread_mock = double(Thread)
+      thread_mock.should_receive(:join)
+      described_class.instance_variable_set(:@threads, [thread_mock])
+      described_class.stop
+    end
+
+    it 'sets running to false' do
+      described_class.instance_variable_set(:@threads, [])
+      described_class.stop
+      described_class.instance_variable_get(:@running).should be_false
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class UtilTest
+  include ::Protobuf::Rpc::Zmq::Util
+end
+
+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 {
+        subject.zmq_error_check(-1)
+      }.to raise_error
+    end
+
+    it 'retrieves the error string from ZeroMQ' do
+      ZMQ::Util.stub(:error_string).and_return('an error from zmq')
+      expect {
+        subject.zmq_error_check(-1)
+      }.to raise_error(RuntimeError, /an error from zmq/i)
+    end
+
+    it 'does nothing if the error code is > 0' do
+      expect {
+        subject.zmq_error_check(1)
+      }.to_not raise_error
+    end
+
+    it 'does nothing if the error code is == 0' do
+      expect {
+        subject.zmq_error_check(0)
+      }.to_not raise_error
+    end
+  end
+
+  describe '#log_signature' do
+    it 'returns the signature for the log' do
+      subject.log_signature.should include('server', 'UtilTest')
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe ::Protobuf::Rpc::Zmq::Worker do
+  before(:each) do 
+    load 'protobuf/zmq.rb'
+  end
+
+  after(:each) do
+    subject.instance_variable_get(:@socket).close
+    subject.instance_variable_get(:@zmq_context).terminate
+  end
+
+  subject do
+    described_class.new({ :host => '127.0.0.1', :port => 9400 })
+  end
+
+  it 'sets the context' do
+    subject.instance_variable_get(:@zmq_context).should be_a(::ZMQ::Context)
+  end
+
+  it 'sets the poller' do
+    subject.instance_variable_get(:@socket).should be_a(::ZMQ::Socket)
+  end
+
+  it 'sets the socket' do
+    subject.instance_variable_get(:@poller).should be_a(::ZMQ::Poller)
+  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

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

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'protobuf/rpc/service_dispatcher'
+
+describe Protobuf::Rpc::ServiceDispatcher do
+  let(:service_name) { 'Test::ResourceService' }
+  let(:method_name) { 'find' }
+  let(:request) { Test::ResourceFindRequest.new(:name => 'resource') }
+  let(:request_bytes) { request.to_s }
+  let(:response) { Test::Resource.new }
+  let(:wrapper) do
+    Protobuf::Socketrpc::Request.new({ :service_name => service_name,
+                                       :method_name => method_name,
+                                       :request_proto => request_bytes })
+
+  end
+
+  subject { described_class.new(wrapper) }
+
+  context 'creating a new dispatcher' do
+    its(:service) { should be_instance_of service_name.constantize }
+    its(:callable_method) { should respond_to(:call)}
+    its(:outer_request) { should eq wrapper }
+    its(:error) { should be_nil }
+
+    context 'when service name is not a valid constant' do
+      let(:service_name) { 'FlibbityGibbit' }
+      its(:success?) { should be_false }
+      its(:error) { should be_instance_of(Protobuf::Rpc::ServiceNotFound) }
+    end
+
+    context 'when method is not defined by the service' do
+      let(:method_name) { 'holly_hooby_whaty' }
+      its(:success?) { should be_false }
+      its(:error) { should be_instance_of(Protobuf::Rpc::MethodNotFound) }
+    end
+
+    context 'when method is defined but is not an rpc method' do
+      before do
+        class Test::Resource
+          def non_rpc_method; end
+        end
+      end
+
+      let(:method_name) { 'non_rpc_method' }
+      its(:success?) { should be_false }
+      its(:error) { should be_instance_of(Protobuf::Rpc::MethodNotFound) }
+    end
+  end
+
+  describe '#invoke!' do
+    context 'regular invocation' do
+      before { subject.callable_method.should_receive(:call) }
+      before { subject.service.stub(:response).and_return(response) }
+      before { subject.invoke! }
+      its(:response) { should be_instance_of Test::Resource }
+      its(:success?) { should be_true }
+    end
+
+    context 'when service responds with' do
+      context 'a hash object' do
+        before { subject.callable_method.should_receive(:call) }
+        before { subject.service.stub(:response).and_return({ :name => 'returned' }) }
+        before { subject.invoke! }
+        its(:success?) { should be_true }
+        its(:response) { should eq Test::Resource.new(:name => 'returned') }
+      end
+
+      context 'an object that responds to to_hash but is not a hash' do
+        let(:hashable) do
+          mock('hashable', :to_hash => { :name => 'hashable' })
+        end
+        before { subject.callable_method.should_receive(:call) }
+        before { subject.service.stub(:response).and_return(hashable) }
+        before { subject.invoke! }
+        its(:success?) { should be_true }
+        its(:response) { should eq Test::Resource.new(:name => 'hashable') }
+      end
+
+      context 'an object that responds to to_proto' do
+        let(:protoable) do
+          mock('protoable', :to_proto => Test::Resource.new(:name => 'protoable'))
+        end
+        before { subject.callable_method.should_receive(:call) }
+        before { subject.service.stub(:response).and_return(protoable) }
+        before { subject.invoke! }
+        its(:success?) { should be_true }
+        its(:response) { should eq Test::Resource.new(:name => 'protoable') }
+      end
+
+      context 'a type not identified by the rpc definition' do
+        before { subject.callable_method.should_receive(:call) }
+        before { subject.service.stub(:response).and_return("I'm not a valid response") }
+        before { subject.invoke! }
+        its(:error) { should be_instance_of(Protobuf::Rpc::BadResponseProto) }
+      end
+    end
+
+    context 'when service invokes rpc failed callback' do
+      before(:all) do
+        class Test::ResourceService
+          rpc :find_with_rpc_failed, Test::ResourceFindRequest, Test::Resource
+          def find_with_rpc_failed
+            rpc_failed('Find failed')
+          end
+        end
+      end
+
+      let(:method_name) { 'find_with_rpc_failed' }
+      before { subject.service.find_with_rpc_failed }
+
+      its(:success?) { should be_false }
+      its(:error) { should be_instance_of(Protobuf::Rpc::RpcFailed) }
+    end
+  end
+
+end