protobuffy 3.1.0

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

@@ -0,0 +1,129 @@
+require 'spec_helper'
+require 'protobuf/zmq'
+
+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"
+  }}
+
+  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
+
+  before do
+    ::ZMQ::Context.stub(:new).and_return(zmq_context_double)
+  end
+
+  before(:all) do
+    @ping_port_before = ENV['PB_RPC_PING_PORT']
+  end
+
+  after(:all) do
+    ENV['PB_RPC_PING_PORT'] = @ping_port_before
+  end
+
+  describe "#lookup_server_uri" do
+    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
+
+    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"
+      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"
+      end
+    end
+
+    context "when the service directory is not running" 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"
+      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"
+    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
+      end
+    end
+
+  end
+
+  describe "#host_alive?" do
+    context "when the PB_RPC_PING_PORT is not set" do
+      before do
+        ENV.delete("PB_RPC_PING_PORT")
+      end
+
+      it "returns true" do
+        subject.send(:host_alive?, "yip.yip").should be_true
+      end
+
+      it "does not attempt a connection" do
+        TCPSocket.should_not_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"
+      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
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Protobuf::Rpc::Middleware::ExceptionHandler do
+  let(:app) { Proc.new { |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)
+      subject.call(env)
+    end
+
+    it "returns the env" do
+      subject.call(env).should 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!') }
+
+      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.
+          stack_env.response.class.should eq error.class
+        end
+
+        it "encodes the response" do
+          stack_env = subject.call(env)
+          stack_env.encoded_response.should 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 { app.stub(: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
+        end
+
+        it "encodes the wrapped exception" do
+          stack_env = subject.call(env)
+          stack_env.encoded_response.should eq encoded_error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Protobuf::Rpc::Middleware::Logger do
+  let(:app) { Proc.new { |inner_env| inner_env } }
+  let(:env) {
+    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,
+    )
+  }
+  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(
+      :service_name => service_name,
+      :method_name => method_name.to_s,
+      :request_proto => request
+    )
+  }
+  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
+      app.should_receive(:call).with(env)
+      subject.call(env)
+    end
+
+    it "returns the env" do
+      subject.call(env).should eq env
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Protobuf::Rpc::Middleware::RequestDecoder do
+  let(:app) { Proc.new { |env| env } }
+  let(:client_host) { 'client_host.test.co' }
+  let(:env) {
+    Protobuf::Rpc::Env.new(
+      'encoded_request' => encoded_request,
+      'log_signature' => 'log_signature'
+    )
+  }
+  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(
+      :caller => client_host,
+      :service_name => service_name,
+      :method_name => method_name.to_s,
+      :request_proto => request
+    )
+  }
+  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)
+      stack_env.request.should eq request
+    end
+
+    it "calls the stack" do
+      app.should_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
+    end
+
+    it "sets Env#service_name" do
+      stack_env = subject.call(env)
+      stack_env.service_name.should 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
+    end
+
+    it "sets Env#request_type" do
+      stack_env = subject.call(env)
+      stack_env.request_type.should eq request_type
+    end
+
+    it "sets Env#response_type" do
+      stack_env = subject.call(env)
+      stack_env.response_type.should eq response_type
+    end
+
+    it "sets Env#rpc_method" do
+      stack_env = subject.call(env)
+      stack_env.rpc_method.should eq rpc_method
+    end
+
+    it "sets Env#rpc_service" do
+      stack_env = subject.call(env)
+      stack_env.rpc_service.should eq rpc_service
+    end
+
+    context "when decoding fails" do
+      before { Protobuf::Socketrpc::Request.stub(: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) {
+        Protobuf::Socketrpc::Request.new(
+          :caller => client_host,
+          :service_name => 'Foo',
+          :method_name => method_name.to_s,
+          :request_proto => request
+        )
+      }
+
+      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) {
+        Protobuf::Socketrpc::Request.new(
+          :caller => client_host,
+          :service_name => service_name,
+          :method_name => 'foo',
+          :request_proto => request
+        )
+      }
+
+      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'
+
+describe Protobuf::Rpc::Middleware::ResponseEncoder do
+  let(:app) { Proc.new { |env| env.response = response; env } }
+  let(:env) {
+    Protobuf::Rpc::Env.new(
+      'response_type' => Test::Resource,
+      'log_signature' => 'log_signature'
+    )
+  }
+  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)
+      stack_env.encoded_response.should eq encoded_response
+    end
+
+    it "calls the stack" do
+      stack_env = subject.call(env)
+      stack_env.response.should 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)
+        stack_env.response.should 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)
+        stack_env.response.should 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)
+        stack_env.encoded_response.should eq encoded_response
+      end
+    end
+
+    context "when encoding fails" do
+      before { Protobuf::Socketrpc::Response.any_instance.stub(: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/http/server_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'protobuf/rpc/servers/http/server'
+
+# A simple service:
+require 'protobuf/message'
+require 'protobuf/rpc/service'
+
+module ReverseModule
+  class ReverseRequest < ::Protobuf::Message
+    required :string, :input, 1
+  end
+  class ReverseResponse < ::Protobuf::Message
+    required :string, :reversed, 1
+  end
+  class ReverseService < ::Protobuf::Rpc::Service
+    rpc :reverse, ReverseRequest, ReverseResponse
+    def reverse
+      respond_with :reversed => request.input.reverse
+    end
+  end
+end
+
+describe Protobuf::Rpc::Http::Server do
+  subject { described_class.new }
+
+  describe '#call' do
+    client = nil
+    before do
+      client = Rack::MockRequest.new(subject)
+    end
+
+    it 'should return the correct response for ReverseModule::ReverseService.reverse' do
+      response = client.post "/ReverseModule%3A%3AReverseService/reverse", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode()
+      response.status.should eq 200
+      response.headers['content-type'].should eq "application/x-protobuf"
+      response.headers['x-protobuf-error'].should be_nil
+      response.headers['x-protobuf-error-reason'].should be_nil
+      response.body.should eq ReverseModule::ReverseResponse.new(:reversed => "hello world".reverse).encode()
+    end
+
+    it 'should return METHOD_NOT_FOUND for ReverseModule::ReverseService.bobloblaw' do
+      response = client.post "/ReverseModule%3A%3AReverseService/bobloblaw", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode()
+      response.status.should eq 404
+      response.headers['content-type'].should eq "application/x-protobuf"
+      response.headers['x-protobuf-error'].should eq "ReverseModule::ReverseService#bobloblaw is not a defined RPC method."
+      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::METHOD_NOT_FOUND.to_s
+      response.body.should eq ""
+    end
+
+    it 'should return SERVICE_NOT_FOUND for Bar::ReverseService.reverse' do
+      response = client.post "/Bar%3A%3AReverseService/reverse", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode()
+      response.status.should eq 404
+      response.headers['content-type'].should eq "application/x-protobuf"
+      response.headers['x-protobuf-error'].should eq "Service class Bar::ReverseService is not defined."
+      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::SERVICE_NOT_FOUND.to_s
+      response.body.should eq ""
+    end
+
+    it 'should return RPC_FAILED for missing input' do
+      response = client.post "/ReverseModule%3A%3AReverseService/reverse", :input => ""
+      response.status.should eq 500
+      response.headers['content-type'].should eq "application/x-protobuf"
+      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::RPC_FAILED.to_s
+      response.body.should eq ""
+    end
+
+    it 'should return RPC_ERROR for invalid input' do
+      response = client.post "/ReverseModule%3A%3AReverseService/reverse", :input => "\\n\\x03foo"
+      response.status.should eq 500
+      response.headers['content-type'].should eq "application/x-protobuf"
+      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::RPC_ERROR.to_s
+      response.body.should eq ""
+    end
+
+    it 'should return INVALID_REQUEST_PROTO for invalid URL' do
+      response = client.post "/foo", :input => ReverseModule::ReverseRequest.new(:input => "hello world").encode()
+      response.status.should eq 400
+      response.headers['content-type'].should eq "application/x-protobuf"
+      # response.headers['x-protobuf-error'].should eq "Service class Bar::ReverseService is not defined."
+      response.headers['x-protobuf-error-reason'].should eq Protobuf::Socketrpc::ErrorReason::INVALID_REQUEST_PROTO.to_s
+      response.body.should eq ""
+    end
+  end
+
+  describe '.running?' do
+    it 'returns true if running' do
+      subject.instance_variable_set(:@running, true)
+      subject.running?.should be_true
+    end
+
+    it 'returns false if not running' do
+      subject.instance_variable_set(:@running, false)
+      subject.running?.should be_false
+    end
+  end
+
+  describe '.stop' do
+    it 'sets running to false' do
+      # subject.instance_variable_set(:@workers, [])
+      subject.stop
+      subject.instance_variable_get(:@running).should be_false
+    end
+  end
+end