protobuf 2.8.13 → 3.0.0.rc1

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 { |env| 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/socket_server_spec.rb

@@ -1,7 +1,6 @@
 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
@@ -32,11 +31,6 @@ describe Protobuf::Rpc::Socket::Server do
     @server.should respond_to(:stop)
   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
     @server.should be_running
   end

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

@@ -42,4 +42,14 @@ describe ::Protobuf::Rpc::Zmq::Util do
       subject.log_signature.should 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/service_dispatcher_spec.rb

@@ -2,115 +2,40 @@ 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) }
+  let(:app) { proc { |env| env } }
+  let(:env) {
+    Protobuf::Rpc::Env.new(
+      'method_name' => method_name,
+      'rpc_service' => service_class,
+      'service_name' => service_name,
+    )
+  }
+  let(:method_name) { :find }
+  let(:response) { response_type.new(:name => 'required') }
+  let(:response_type) { service_class.rpcs[method_name].response_type }
+  let(:rpc_service) { service_class.new(env) }
+  let(:service_class) { Test::ResourceService }
+  let(:service_name) { service_class.to_s }
+
+  subject { described_class.new(app) }
+
+  before { subject.stub(:rpc_service).and_return(rpc_service) }
+
+  describe '#call' do
+    before { rpc_service.stub(:callable_rpc_method).and_return(lambda {}) }
+    before { rpc_service.stub(:response).and_return(response) }
+
+    it "dispatches the request" do
+      stack_env = subject.call(env)
+      stack_env.response.should eq response
     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 the given RPC method is not implemented" do
+      before { rpc_service.stub(:callable_rpc_method).and_return(lambda { rpc_service.__send__(:foo) }) }
 
-    context 'when method is defined but is not an rpc method' do
-      before do
-        class Test::Resource
-          def non_rpc_method; end
-        end
+      it "raises a method not found exception" do
+        expect { subject.call(env) }.to raise_exception(Protobuf::Rpc::MethodNotFound)
       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
-          double('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
-          double('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

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

@@ -416,7 +416,7 @@ describe Protobuf::Rpc::ServiceFilters do
           subject.__send__(:run_filters, :endpoint)
           subject.called.should eq([ :filter_with_error3, :custom_error_occurred ])
           subject.ex_class.should eq CustomError3
-        }.to_not raise_error(CustomError3)
+        }.not_to raise_error
       end
     end
 
@@ -437,7 +437,7 @@ describe Protobuf::Rpc::ServiceFilters do
             subject.__send__(:run_filters, :endpoint)
             subject.called.should eq([ :filter_with_error1, :custom_error_occurred ])
             subject.ex_class.should eq CustomError1
-          }.to_not raise_error(CustomError1)
+          }.not_to raise_error
         end
       end
     end
@@ -457,7 +457,7 @@ describe Protobuf::Rpc::ServiceFilters do
           subject.__send__(:run_filters, :endpoint)
           subject.called.should eq([ :filter_with_error1, :block_rescue_handler ])
           subject.ex_class.should eq CustomError1
-        }.to_not raise_error(CustomError1)
+        }.not_to raise_error
       end
     end
 
@@ -476,7 +476,7 @@ describe Protobuf::Rpc::ServiceFilters do
           subject.__send__(:run_filters, :endpoint)
           subject.called.should eq([ :filter_with_runtime_error, :standard_error_rescue_handler ])
           subject.ex_class.should eq RuntimeError
-        }.to_not raise_error
+        }.not_to raise_error
       end
     end
   end

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

@@ -120,18 +120,21 @@ describe Protobuf::Rpc::Service do
         end
       end
 
-
-      let(:request) do
-        Test::ResourceFindRequest.new(:name => 'resource')
-      end
-
-      let(:response) do
-        Test::Resource.new
-      end
+      let(:request) { Test::ResourceFindRequest.new(:name => 'resource') }
+      let(:response) { Test::Resource.new }
 
       context 'when calling the rpc method' do
         context 'when response is implied' do
-          subject { NewTestService.new(:find_with_implied_response, request.encode) }
+          let(:env) {
+            Protobuf::Rpc::Env.new(
+              'request' => request,
+              'response_type' => response_type
+            )
+          }
+          let(:response_type) { service.rpcs[:find_with_implied_response].response_type }
+          let(:service) { NewTestService }
+
+          subject { NewTestService.new(env) }
 
           before { subject.find_with_implied_response }
           its(:response) { should be_a(Test::Resource) }
@@ -139,27 +142,20 @@ describe Protobuf::Rpc::Service do
         end
 
         context 'when using respond_with paradigm' do
-          subject { NewTestService.new(:find_with_respond_with, request.encode) }
+          let(:env) {
+            Protobuf::Rpc::Env.new(
+              'method_name' => :find_with_respond_with,
+              'request' => request
+            )
+          }
+
+          subject { NewTestService.new(env) }
 
           before { subject.find_with_respond_with }
           its(:response) { should be_a(Test::Resource) }
           specify { subject.response.name.should eq 'Custom response' }
         end
       end
-
-      context 'when calling rpc_failed in the method' do
-        subject { NewTestService.new(:find_with_rpc_failed, request.encode) }
-
-        it 'invokes the rpc_failed callback with the error' do
-          error = nil
-          subject.on_rpc_failed(lambda { |err| error = err })
-          subject.find_with_rpc_failed
-          error.should eq 'This is a failed endpoint'
-          subject.response.name.should eq 'Name will still be set'
-        end
-      end
     end
-
   end
-
 end

data/spec/lib/protobuf_spec.rb

@@ -26,15 +26,15 @@ describe ::Protobuf do
       described_class.connector_type.should eq :socket
     end
 
-    it 'accepts socket, evented, or zmq' do
-      [:socket, :evented, :zmq].each do |type|
+    it 'accepts socket or zmq' do
+      [:socket, :zmq].each do |type|
         described_class.connector_type = type
         described_class.connector_type.should eq type
       end
     end
 
     it 'does not accept other types' do
-      [:hello, :world].each do |type|
+      [:hello, :world, :evented].each do |type|
         expect {
           described_class.connector_type = type
         }.to raise_error(ArgumentError)

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'simplecov'
 SimpleCov.start
 
+require 'timeout'
 require 'rubygems'
 require 'bundler'
 Bundler.setup :default, :development, :test
@@ -10,6 +11,7 @@ $: << ::File.expand_path('../..', __FILE__)
 $: << ::File.expand_path('../support', __FILE__)
 
 require 'protobuf'
+require 'protobuf/rpc/server'
 require ::File.expand_path('../support/all', __FILE__)
 
 $: << ::File.expand_path("../../lib/protobuf/descriptors", __FILE__)
@@ -30,11 +32,10 @@ ENV.delete("PB_IGNORE_DEPRECATIONS")
 
   c.before(:suite) do
     unless ENV['NO_COMPILE_TEST_PROTOS']
+      require 'rake'
+      load ::File.expand_path('../../Rakefile', __FILE__)
       $stdout.puts 'Compiling test protos (use NO_COMPILE_TEST_PROTOS=1 to skip)'
-      proto_path = File.expand_path("../support/", __FILE__)
-      cmd = %Q{protoc --plugin=./bin/protoc-gen-ruby --ruby_out=#{proto_path} -I #{proto_path} #{File.join(proto_path, '**', '*.proto')}}
-      puts cmd
-      %x{#{cmd}}
+      ::Rake::Task['compile:spec']
     end
   end
 end

data/spec/support/packed_field.rb

@@ -1,21 +1,22 @@
-shared_examples_for :packable_field do |klass|
+if defined?(RSpec)
+  shared_examples_for :packable_field do |field_klass|
 
-  before(:all) do
-    unless defined?(PackableFieldTest)
-      class PackableFieldTest < ::Protobuf::Message; end
-    end
+    before(:all) do
+      unless defined?(PackableFieldTest)
+        class PackableFieldTest < ::Protobuf::Message; end
+      end
 
-    field_klass = klass
-    field_name = "#{klass.name.split('::').last.underscore}_packed_field".to_sym
-    tag_num = PackableFieldTest.fields.size + 1
-    PackableFieldTest.repeated(field_klass, field_name, tag_num, :packed => true)
-  end
+      field_name = "#{field_klass.name.split('::').last.underscore}_packed_field".to_sym
+      tag_num = PackableFieldTest.fields.size + 1
+      PackableFieldTest.repeated(field_klass, field_name, tag_num, :packed => true)
+    end
 
-  let(:field_name) { "#{klass.name.split('::').last.underscore}_packed_field" }
-  let(:message_instance) { PackableFieldTest.new(field_name => [100, 200, 300]) }
+    let(:field_name) { "#{field_klass.name.split('::').last.underscore}_packed_field".to_sym }
+    let(:message_instance) { PackableFieldTest.new(field_name => [100, 200, 300]) }
 
-  subject { message_instance.fields.last }
+    subject { PackableFieldTest.get_field(field_name) }
 
- it { should be_packed }
+    it { should be_packed }
 
+  end
 end